| public ConnectAsync ( System uri, System cancellationToken ) : System.Threading.Tasks.Task | ||
| uri | System | |
| cancellationToken | System | |
| return | System.Threading.Tasks.Task | |
private void TestWebSockets()
{
var socket = new ClientWebSocket();
Console.WriteLine("Connecting");
socket.ConnectAsync(new Uri("wss://echo.websocket.org"), CancellationToken.None).Wait();
Console.WriteLine("Sending");
socket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), WebSocketMessageType.Text, true, CancellationToken.None).Wait();
var buffer = new byte[1024];
Console.WriteLine("Receiving");
var result = socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None).Result;
Console.WriteLine($"Recieved: {Encoding.UTF8.GetString(buffer, 0, result.Count)}");
}
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options)
{
if (_ws != null)
{
_ws.Dispose();
}
//ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, errors) =>
//{
// //// local dev, just approve all certs
// //if (development) return true;
// //return errors == SslPolicyErrors.None;
// return true;
//};
_ws = CreateClient();
//var cert = new X509Certificate2(@"C:\Users\41608\Downloads\cert\client1-crt.pem");
//var privateKey = cert.PrivateKey as RSACryptoServiceProvider;
//privateKey.en
//_ws.Options.ClientCertificates.Add(cert);
_connectionToken = new CancellationTokenSource();
await _ws.ConnectAsync(uri, _connectionToken.Token);
await Task.Factory.StartNew(ListenAsync, _connectionToken.Token);
await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token);
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService<IMyService>(new MyService());
listener.Start();
var client = new ClientWebSocket();
client.Options.AddSubProtocol("SignalR");
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<IMyService>();
client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public virtual Stream Connect(Uri uri, bool requireAuthentication) {
// IIS starts python.exe processes lazily on the first incoming request, and will terminate them after a period
// of inactivity, making it impossible to attach. So before trying to connect to the debugger, "ping" the website
// via HTTP to ensure that we have something to connect to.
try {
var httpRequest = WebRequest.Create(new UriBuilder(uri) { Scheme = "http", Port = -1, Path = "/" }.Uri);
httpRequest.Method = WebRequestMethods.Http.Head;
httpRequest.Timeout = 5000;
httpRequest.GetResponse().Dispose();
} catch (WebException) {
// If it fails or times out, just go ahead and try to connect anyway, and rely on normal error reporting path.
}
var webSocket = new ClientWebSocket();
try {
webSocket.ConnectAsync(uri, CancellationToken.None).GetAwaiter().GetResult();
var stream = new WebSocketStream(webSocket, ownsSocket: true);
webSocket = null;
return stream;
} catch (WebSocketException ex) {
throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
} catch (IOException ex) {
throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
} catch (PlatformNotSupportedException ex) {
throw new ConnectionException(ConnErrorMessages.RemoteUnsupportedTransport, ex);
} finally {
if (webSocket != null) {
webSocket.Dispose();
}
}
}
public async void ConnectAndStartReceivingToWebSocket()
{
ClientWebSocket webSocket = null;
var uncontext = new Uri(_wsLiteratureUncontextCom);
try
{
webSocket = new ClientWebSocket();
await webSocket.ConnectAsync(uncontext, CancellationToken.None);
await Receive(webSocket);
}
catch (Exception ex)
{
Console.WriteLine("Exception: {0}", ex);
}
finally
{
if (webSocket != null)
{
webSocket.Dispose();
UncontextedData.OnCompleted();
}
Console.WriteLine("Closed websocket.");
}
}
public async Task WebsocketBasic(HostType hostType)
{
using (ApplicationDeployer deployer = new ApplicationDeployer())
{
string applicationUrl = deployer.Deploy(hostType, WebsocketBasicConfiguration);
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(applicationUrl.Replace("http://", "ws://")), CancellationToken.None);
var receiveBody = new byte[100];
for (int i = 0; i < 4; i++)
{
var message = "Message " + i.ToString();
byte[] sendBody = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(sendBody), WebSocketMessageType.Text, true, CancellationToken.None);
var receiveResult = await client.ReceiveAsync(new ArraySegment<byte>(receiveBody), CancellationToken.None);
Assert.Equal(WebSocketMessageType.Text, receiveResult.MessageType);
Assert.True(receiveResult.EndOfMessage);
Assert.Equal(sendBody.Length, receiveResult.Count);
Assert.Equal(message, Encoding.UTF8.GetString(receiveBody, 0, receiveResult.Count));
}
}
}
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var server = new HttpListener();
server.Prefixes.Add("http://localhost:20000/");
server.Start();
var serverTransport = server.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService<IMyService>(new MyService());
var client = new ClientWebSocket();
client.Options.SetBuffer(8192, 8192);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<IMyService>();
client.ConnectAsync(new Uri("ws://localhost:20000/"), CancellationToken.None).Wait();
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
server.Stop();
server.Close();
}
/// <summary>
///
/// </summary>
/// <param name="uri"></param>
/// <param name="options"></param>
/// <exception cref="TimeoutException"></exception>
/// <exception cref="WebSocketException"></exception>
/// <returns></returns>
public async Task ConnectAsync(Uri uri)
{
//#if NET45
//#elif NETSTANDARD2_0
//#endif
//if (_io.Options.Proxy != null)
//{
// _ws.Options.Proxy = _io.Options.Proxy;
//}
if (_ws != null)
{
_ws.Dispose();
}
_ws = new System.Net.WebSockets.ClientWebSocket();
Options = _ws.Options;
_wsWorkTokenSource = new CancellationTokenSource();
var wsConnectionTokenSource = new CancellationTokenSource(_io.Options.ConnectionTimeout);
try
{
await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token);
await Task.Factory.StartNew(ListenAsync);
await Task.Factory.StartNew(ListenStateAsync);
}
catch (TaskCanceledException)
{
throw new TimeoutException();
}
}
public static async Task RunSample()
{
ClientWebSocket websocket = new ClientWebSocket();
string url = "ws://localhost:7000/";
Console.WriteLine("Connecting to: " + url);
await websocket.ConnectAsync(new Uri(url), CancellationToken.None);
int seed = 20000;
Task[] taskList = new Task[seed];
Stopwatch sw = new Stopwatch();
sw.Restart();
for (var i = 0; i < seed; i++)
{
//taskList[i] = Send(websocket);
await Send(websocket);
}
//Task.WaitAll(taskList);
sw.Stop();
Console.WriteLine("seed:{0}, time:{1}", seed, sw.ElapsedMilliseconds);
//if (result.CloseStatus.HasValue)
//{
// Console.WriteLine("Closed; Status: " + result.CloseStatus + ", " + result.CloseStatusDescription);
//}
//else
//{
// Console.WriteLine("Received message: " + Encoding.UTF8.GetString(incomingData, 0, result.Count));
//}
}
internal async Task<IAsyncTransport> ConnectAsync(Address address, Action<ClientWebSocketOptions> options)
{
Uri uri = new UriBuilder()
{
Scheme = address.Scheme,
Port = GetDefaultPort(address.Scheme, address.Port),
Host = address.Host,
Path = address.Path
}.Uri;
ClientWebSocket cws = new ClientWebSocket();
cws.Options.AddSubProtocol(WebSocketSubProtocol);
if (options != null)
{
options(cws.Options);
}
await cws.ConnectAsync(uri, CancellationToken.None);
if (cws.SubProtocol != WebSocketSubProtocol)
{
cws.Abort();
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
"WebSocket SubProtocol used by the host is not the same that was requested: {0}",
cws.SubProtocol ?? "<null>"));
}
this.webSocket = cws;
return this;
}
public async void TestConnectWebSocket()
{
if (TestHelper.IsMono)
{
Assert.Inconclusive("Mono doesn't have support to WebSockets");
}
Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule");
Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler");
var clientSocket = new ClientWebSocket();
var ct = new CancellationTokenSource();
await clientSocket.ConnectAsync(new Uri(Resources.WsServerAddress + "/test"), ct.Token);
Assert.AreEqual(clientSocket.State, WebSocketState.Open, "Connection is open");
var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA"));
var buffer = new ArraySegment<byte>(new byte[1024]);
await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token);
var result = await clientSocket.ReceiveAsync(buffer, ct.Token);
Assert.IsTrue(result.EndOfMessage);
Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME");
}
public static async Task RunSample()
{
ClientWebSocket websocket = new ClientWebSocket();
string url = "ws://localhost:5000/";
Console.WriteLine("Connecting to: " + url);
await websocket.ConnectAsync(new Uri(url), CancellationToken.None);
string message = "Hello World";
Console.WriteLine("Sending message: " + message);
byte[] messageBytes = Encoding.UTF8.GetBytes(message);
await websocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None);
byte[] incomingData = new byte[1024];
WebSocketReceiveResult result = await websocket.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
if (result.CloseStatus.HasValue)
{
Console.WriteLine("Closed; Status: " + result.CloseStatus + ", " + result.CloseStatusDescription);
}
else
{
Console.WriteLine("Received message: " + Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
public static async Task Connect(string uri)
{
ClientWebSocket webSocket = null;
try
{
webSocket = new ClientWebSocket();
await webSocket.ConnectAsync(new Uri(uri), CancellationToken.None);
await Task.WhenAll(Receive(webSocket), Send(webSocket));
}
catch (Exception ex)
{
Console.WriteLine("Exception: {0}", ex);
}
finally
{
if (webSocket != null)
webSocket.Dispose();
Console.WriteLine();
lock (consoleLock)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("WebSocket closed.");
Console.ResetColor();
}
}
}
public async Task ListenAsync()
{
var socket = new ClientWebSocket();
await socket.ConnectAsync(new Uri(ServerUrl.Replace("http://", "ws://")), CancellationToken.None);
// listen for updates
await Receive(socket);
}
public void ConnectPusher()
{
_ws = new ClientWebSocket();
_ws.ConnectAsync(new Uri("wss://ws.pusherapp.com/app/de504dc5763aeef9ff52?client=PC-Orbit&version=1.0&protocol=7"), _source.Token).Wait();
_connected = true;
ThreadingHelper.Thread(OnReceive).Launch();
}
protected override void Main()
{
if (Environment.OSVersion.Version < new Version(6, 2))
{
TraceError(Text.LabRequiresWindows8OrHigher);
return;
}
const int port = 5494;
string subProtocol = GetType().Name;
var userMessages = new BehaviorSubject<string>(null);
var client = new ClientWebSocket();
client.Options.AddSubProtocol(subProtocol);
using (client)
using (var cancel = new CancellationDisposable())
using (ObservableHttpListener
.StartWebSockets(new IPEndPoint(IPAddress.Loopback, port), subProtocol)
.Subscribe(
async request =>
{
using (var socket = request.WebSocket)
{
try
{
var message = await ReceiveMessageAsync(socket, cancel.Token);
await SendMessageAsync("You sent \"" + message + "\"", socket, cancel.Token);
await ReceiveCloseMessageAsync(socket, cancel.Token);
}
catch (OperationCanceledException)
{
}
}
},
TraceError))
using ((from _ in client.ConnectAsync(new Uri("ws://localhost:" + port), cancel.Token).ToObservable()
.Do(_ => TraceLine(Environment.NewLine + "(Connected to host on sub-protocol \"{0}\")", client.SubProtocol))
from message in userMessages.Where(m => m != null).Take(1)
from __ in SendMessageAsync(message, client, cancel.Token).ToObservable()
from response in ReceiveMessageAsync(client, cancel.Token).ToObservable()
.Do(___ => client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", cancel.Token))
select response)
.Subscribe(
response => TraceLine("Response: {0}", response),
TraceError,
() => TraceLine("{0}: {1}", Text.Client, Text.Done)))
{
userMessages.OnNext(UserInput("{0}> ", Instructions.EnterAMessage));
TraceStatus(Instructions.PressAnyKeyToCancel);
WaitForKey();
}
}
public async Task Connect(string host, CancellationToken cancelToken)
{
_webSocket = new WebSocketClient();
_webSocket.Options.Proxy = null;
_webSocket.Options.SetRequestHeader("User-Agent", _config.UserAgent);
_webSocket.Options.KeepAliveInterval = TimeSpan.Zero;
_tempTask = await _webSocket.ConnectAsync(new Uri(host), cancelToken)//.ConfigureAwait(false);
.ContinueWith(t => ReceiveAsync(cancelToken)).ConfigureAwait(false);
//TODO: ContinueWith is a temporary hack, may be a bug related to https://github.com/dotnet/corefx/issues/4429
}
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options)
{
_ws = new System.Net.WebSockets.ClientWebSocket();
_connectionToken = new CancellationTokenSource();
await _ws.ConnectAsync(uri, _connectionToken.Token);
await Task.Factory.StartNew(ListenAsync, _connectionToken.Token);
await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token);
}
private static async Task startRunner()
{
var socketUrl = await getSocketUrl();
ClientWebSocket ws = new ClientWebSocket();
await ws.ConnectAsync(new Uri($"ws://{socketUrl}"), CancellationToken.None);
var buffer = new byte[1024 * 10];
await send(ws, new CreateNewGameRequestSocketMessage() { GameType = "sevens" });
while (true)
{
var segment = new ArraySegment<byte>(buffer);
var result = await ws.ReceiveAsync(segment, CancellationToken.None);
switch (result.MessageType)
{
case WebSocketMessageType.Binary:
byte[] bytes = new byte[result.Count];
Array.ConstrainedCopy(segment.Array, 0, bytes, 0, result.Count);
var obj = Serializer.Deserialize(bytes);
if (obj is GameStartedSocketMessage)
{
totalGames++;
games++;
}
else if (obj is AskQuestionSocketMessage)
{
var answerQ = (AskQuestionSocketMessage)obj;
await send(ws, new AnswerQuestionSocketMessage()
{
AnswerIndex = (short)(answerQ.Answers.Length > 1 ? 1 : 0)
});
totalAnswers++;
}
else if (obj is GameOverSocketMessage)
{
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", CancellationToken.None);
games--;
return;
}
break;
case WebSocketMessageType.Close:
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", CancellationToken.None);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public async Task Connect(string host, CancellationToken cancelToken)
{
_webSocket = new WebSocketClient();
_webSocket.Options.Proxy = null;
_webSocket.Options.SetRequestHeader("User-Agent", _config.UserAgent);
_webSocket.Options.KeepAliveInterval = TimeSpan.Zero;
_tempTask = await _webSocket.ConnectAsync(new Uri(host), cancelToken)//.ConfigureAwait(false);
.ContinueWith(t => ReceiveAsync(cancelToken)).ConfigureAwait(false);
//TODO: ContinueWith is a temporary hack, may be a bug related to https://github.com/dotnet/corefx/issues/4429
}
private async Task<WebSocket> ConnectAsync(string address, string agent)
{
if (string.Equals(agent, "NativeWebSockets"))
{
var client = new ClientWebSocket();
await client.ConnectAsync(new Uri(address), CancellationToken.None);
return client;
}
else
{
// TODO: BUG: Require ws or wss schemes
var client = new WebSocketClient();
return await client.ConnectAsync(new Uri(address), CancellationToken.None);
}
}
/// <summary>
/// <c>overrideOnOk</c> will be called before the regular onOk has been processed, allowing customization of what happens
/// on that response. Implement this method in a partial class to enable this behavior
/// </summary>
/// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
/// <param name="response">the body result as a <see cref="Microsoft.Azure.PowerShell.Cmdlets.ContainerInstance.Models.Api20210901.IContainerExecResponse"
/// /> from the remote call</param>
/// <param name="returnNow">/// Determines if the rest of the onOk method should be processed, or if the method should return
/// immediately (set to true to skip further processing )</param>
partial void overrideOnOk(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task <Microsoft.Azure.PowerShell.Cmdlets.ContainerInstance.Models.Api20210901.IContainerExecResponse> response, ref global::System.Threading.Tasks.Task <bool> returnNow)
{
var containerExecResponse = response.ConfigureAwait(false).GetAwaiter().GetResult();
socket = new System.Net.WebSockets.ClientWebSocket();
// Connect websocket
socket.ConnectAsync(new System.Uri(containerExecResponse.WebSocketUri), _cancellationTokenSource.Token).ConfigureAwait(false).GetAwaiter().GetResult();
socket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(containerExecResponse.Password)), WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false).GetAwaiter().GetResult();
var receiver = PullResponse();
var sender = PushCommand();
Task.WaitAll(sender, receiver);
returnNow = global::System.Threading.Tasks.Task.FromResult(true);
}
private async Task PerformConnect(bool reconnecting = false)
{
var url = reconnecting ? _connectionInfo.Connection.Url : _connectionInfo.Connection.Url + "connect";
url += TransportHelper.GetReceiveQueryString(_connectionInfo.Connection, _connectionInfo.Data, "webSockets");
var builder = new UriBuilder(url);
builder.Scheme = builder.Scheme == "https" ? "wss" : "ws";
Debug.WriteLine("WS: " + builder.Uri);
var webSocket = new ClientWebSocket();
_connectionInfo.Connection.PrepareRequest(new WebSocketWrapperRequest(webSocket));
await webSocket.ConnectAsync(builder.Uri, _disconnectToken);
await ProcessWebSocketRequestAsync(webSocket, _disconnectToken);
}
private static async Task ConnectToWebSocket()
{
var settingsConfigurator = _serviceProvider.GetService<IConfigureOptions<ClientSettings>>();
settingsConfigurator.Configure(_settings);
ClientWebSocket client = new ClientWebSocket();
var clientId = Guid.NewGuid();
var uri = $"{_settings.SocketBaseHostAddress}?clientId=" + clientId;
await client.ConnectAsync(new Uri(uri), CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var messageDispatcher = new ClientMessageDispatcher(_settings, client, clientId);
await messageDispatcher.Listen();
}
}
public override async Task<WebSocket> CreateWebSocketAsync(Uri address, WebHeaderCollection headers, ICredentials credentials,
WebSocketTransportSettings settings, TimeoutHelper timeoutHelper)
{
ClientWebSocket webSocket = new ClientWebSocket();
webSocket.Options.Credentials = credentials;
webSocket.Options.AddSubProtocol(settings.SubProtocol);
webSocket.Options.KeepAliveInterval = settings.KeepAliveInterval;
foreach (var headerObj in headers)
{
var header = headerObj as string;
webSocket.Options.SetRequestHeader(header, headers[header]);
}
await webSocket.ConnectAsync(address, timeoutHelper.CancellationToken);
return webSocket;
}
private static ClientWebSocket ConnectToWebsocket(ClientWebSocket client, string handle, Helpers.ContainerizerProcess process)
{
client = new ClientWebSocket();
try
{
client.ConnectAsync(
new Uri("ws://localhost:" + process.Port + "/api/containers/" + handle + "/run"),
CancellationToken.None).GetAwaiter().GetResult();
}
catch (WebSocketException ex)
{
throw new Exception("Make sure to enable websockets following instructions in the README.",
ex);
}
return client;
}
public static async Task Run(Control control, Bitmap bitmap)
{
using (var webSocket = new ClientWebSocket())
{
var stream = new WebSocketStream(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:5050/ws"), CancellationToken.None);
await DispatchStartAsync(control, bitmap, stream);
while (true)
{
await DispatchDeltaAsync(control, bitmap, stream);
}
}
}
public async Task ConnectAsync(string url)
{
await DisconnectAsync();
_disconnectToken = new CancellationTokenSource();
var cancelToken = _disconnectToken.Token;
_webSocket = new ClientWebSocket();
_webSocket.Options.KeepAliveInterval = TimeSpan.Zero;
await _webSocket.ConnectAsync(new Uri(url), cancelToken);
_host = url;
if (_isDebug)
RaiseOnDebugMessage(DebugMessageType.Connection, $"Connected.");
OnConnect();
_lastHeartbeat = DateTime.UtcNow;
_task = Task.Factory.ContinueWhenAll(CreateTasks(), x =>
{
if (_isDebug)
RaiseOnDebugMessage(DebugMessageType.Connection, $"Disconnected.");
//Do not clean up until all tasks have ended
OnDisconnect();
_disconnectToken.Dispose();
_disconnectToken = null;
_wasDisconnectedUnexpected = false;
//Clear send queue
_heartbeatInterval = 0;
_lastHeartbeat = DateTime.MinValue;
_webSocket.Dispose();
_webSocket = null;
byte[] ignored;
while (_sendQueue.TryDequeue(out ignored)) { }
if (_isConnected)
{
_isConnected = false;
RaiseDisconnected(_wasDisconnectedUnexpected);
}
_task = null;
});
}
public WebSocketNetworkClient(Uri uri) {
// iisnode starts node.exe processes lazily on the first incoming request, and will terminate them after a period
// of inactivity, making it impossible to attach. So before trying to connect to the debugger, "ping" the website
// via HTTP to ensure that we have something to connect to.
try {
var httpRequest = WebRequest.Create(new UriBuilder(uri) { Scheme = "http", Port = -1, Path = "/" }.Uri);
httpRequest.Method = WebRequestMethods.Http.Head;
httpRequest.Timeout = 5000;
httpRequest.GetResponse().Dispose();
} catch (WebException) {
// If it fails or times out, just go ahead and try to connect anyway, and rely on normal error reporting path.
}
_webSocket = new ClientWebSocket();
_webSocket.ConnectAsync(uri, CancellationToken.None).GetAwaiter().GetResult();
_stream = new WebSocketStream(_webSocket);
}
private async Task ReadEventsAsync()
{
var socket = new ClientWebSocket();
await socket.ConnectAsync(new Uri("ws://localhost:7070/events"), CancellationToken.None);
while (true)
{
var buffer = new byte[1024];
var segment = new ArraySegment<byte>(buffer);
var result = await socket.ReceiveAsync(segment, CancellationToken.None);
var data = Encoding.UTF8.GetString(segment.Array, 0, result.Count);
Debug.WriteLine(data);
}
}
public void TestMethod1()
{
var total = 10000;
var msg = "hello";
var client = new ClientWebSocket();
client.ConnectAsync(new Uri("ws://localhost:8889/ws.axd"), CancellationToken.None).Wait();
client.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(total.ToString())), WebSocketMessageType.Text, true, CancellationToken.None).Wait();
client.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(msg)), WebSocketMessageType.Text, true, CancellationToken.None).Wait();
var w = new Stopwatch();
w.Start();
ReceiveMessages(client, msg, total).Wait();
w.Stop();
Trace.WriteLine(w.ElapsedMilliseconds);
while (_counter < total) Thread.Sleep(10);
}
private async Task Connect()
{
var nextEndPoint = _endpoints.Dequeue();
_endpoints.Enqueue(nextEndPoint);
_webSocket = new ClientWebSocket();
await _webSocket.ConnectAsync(nextEndPoint, CancellationToken.None);
Beam.Logger.Info($"Connected to endpoint {nextEndPoint}");
_channelJoined = true;
_cancellationToken = new CancellationToken();
_receiveThread = new Thread(StartRecieving)
{
Name = $"Chat Receive Thread for {_channelId}"
};
_receiveThread.Start();
}
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options)
{
if (_ws != null)
{
_ws.Dispose();
}
_ws = new System.Net.WebSockets.ClientWebSocket();
//var cert = new X509Certificate2(@"C:\Users\41608\Downloads\cert\client1-crt.pem");
//var privateKey = cert.PrivateKey as RSACryptoServiceProvider;
//privateKey.en
//_ws.Options.ClientCertificates.Add(cert);
_connectionToken = new CancellationTokenSource();
await _ws.ConnectAsync(uri, _connectionToken.Token);
await Task.Factory.StartNew(ListenAsync, _connectionToken.Token);
await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token);
}
public void ReadWriteTest()
{
var websocket = new ClientWebSocket();
// Set SubProtocol to AMQPWSB10
websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10);
Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix);
websocket.ConnectAsync(uri, CancellationToken.None).Wait(CancellationToken.None);
clientWebSocketTransport = new ClientWebSocketTransport(websocket, IotHubName, null, null);
// Test Write API
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onWriteOperationComplete;
args.SetBuffer(byteArray, 0, byteArray.Length);
clientWebSocketTransport.WriteAsync(args);
// Test Read API
args.CompletedCallback = onReadOperationComplete;
clientWebSocketTransport.ReadAsync(args);
}
public async Task EndToEnd_ConnectAndClose_Success()
{
OwinHttpListener listener = CreateServer(env =>
{
var accept = (WebSocketAccept)env["websocket.Accept"];
Assert.NotNull(accept);
accept(
null,
async wsEnv =>
{
var sendAsync1 = wsEnv.Get<WebSocketSendAsync>("websocket.SendAsync");
var receiveAsync1 = wsEnv.Get<WebSocketReceiveAsync>("websocket.ReceiveAsync");
var closeAsync1 = wsEnv.Get<WebSocketCloseAsync>("websocket.CloseAsync");
var buffer1 = new ArraySegment<byte>(new byte[10]);
await receiveAsync1(buffer1, CancellationToken.None);
await closeAsync1((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
});
return TaskHelpers.Completed();
},
HttpServerAddress);
using (listener)
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment<byte>(new byte[10]), CancellationToken.None);
Assert.Equal(WebSocketCloseStatus.NormalClosure, readResult.CloseStatus);
Assert.Equal("Closing", readResult.CloseStatusDescription);
Assert.Equal(0, readResult.Count);
Assert.True(readResult.EndOfMessage);
Assert.Equal(WebSocketMessageType.Close, readResult.MessageType);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="uri"></param>
/// <param name="options"></param>
/// <exception cref="TimeoutException"></exception>
/// <exception cref="WebSocketException"></exception>
/// <returns></returns>
public async Task ConnectAsync(Uri uri)
{
DisposeWebSocketIfNotNull();
_ws = new System.Net.WebSockets.ClientWebSocket();
Config?.Invoke(_ws.Options);
var wsConnectionTokenSource = new CancellationTokenSource(ConnectionTimeout);
try
{
await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token);
DisposeListenTokenIfNotNull();
_listenToken = new CancellationTokenSource();
_ = ListenAsync(_listenToken.Token);
}
catch (TaskCanceledException)
{
throw new TimeoutException();
}
}
internal void Run()
{
try
{
// set the server verification callback if connecting via wss
if (String.Compare("wss", uri.Scheme, true) == 0)
{
sp = ServicePointManager.FindServicePoint(this.uri);
sp.Expect100Continue = true;
}
if (!clientWebSocket.ConnectAsync(this.uri, CancellationToken.None).Wait(this.timeout))
{
throw new Exception("timeout");
}
// notify listener
notifyOpen();
// dispatch frames
dispatch();
}
catch (Exception e)
{
String message = "failed to connect";
for (Exception inner = e.InnerException; inner != null; inner = inner.InnerException)
{
message += (" : " + inner.Message);
}
Exception exp = new Exception(message);
notifyError(exp);
}
finally
{
// ignore
}
}
/// <summary>
/// Connect to the specified host, handshake and prepare the listening task.
/// </summary>
/// <param name="host">The URI of the host, usually something like ws://host:port</param>
/// <param name="timeout">The maximum timeout in milliseconds for the function to execute. Will raise exception when timeout is reached.</param>
/// <returns></returns>
internal async System.Threading.Tasks.Task Connect(string host, int timeout)
{
try
{
System.Uri uri = new System.Uri(host);
using (var cts = new System.Threading.CancellationTokenSource())
{
// Connect
if (ws == null)
{
ws = new System.Net.WebSockets.ClientWebSocket();
}
await ws.ConnectAsync(uri, cts.Token);
}
{
// [HELLO, Realm|uri, Details|dict]
await Send($"[{(int)Messages.HELLO},\"realm1\"]", timeout);
}
StartListen();
{
// Should receive the WELCOME
Response response = await ReceiveExpect(Messages.WELCOME, 0, timeout);
sessionId = response.ContextSpecificResultId;
}
}
catch (System.Net.WebSockets.WebSocketException e)
{
ws.Dispose();
ws = new System.Net.WebSockets.ClientWebSocket();
throw new ErrorException(e.ToString());
}
catch (System.Exception e)
{
throw new ErrorException(e.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="uri"></param>
/// <param name="options"></param>
/// <exception cref="TimeoutException"></exception>
/// <exception cref="WebSocketException"></exception>
/// <returns></returns>
public async Task ConnectAsync(Uri uri)
{
if (_ws != null)
{
_ws.Dispose();
}
_ws = new System.Net.WebSockets.ClientWebSocket();
Config?.Invoke(_ws.Options);
_wsWorkTokenSource = new CancellationTokenSource();
var wsConnectionTokenSource = new CancellationTokenSource(_io.Options.ConnectionTimeout);
try
{
await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token);
_ = Task.Run(ListenAsync);
}
catch (TaskCanceledException)
{
throw new TimeoutException();
}
}
public static async Task ConnectAsync(this ClientWebSocket client, string uri)
{
await client.ConnectAsync(new Uri(uri), CancellationToken.None);
}
public Task ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
return(webSocket.ConnectAsync(uri, cancellationToken));
}
public async Task TestConnectWebSocket()
{
var wsUrl = Resources.WsServerAddress + "test";
Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule");
Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler");
#if NET46
var clientSocket = new ClientWebSocket();
var ct = new CancellationTokenSource();
await clientSocket.ConnectAsync(new Uri(wsUrl), ct.Token);
Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open");
var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA"));
var buffer = new ArraySegment<byte>(new byte[1024]);
await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token);
var result = await clientSocket.ReceiveAsync(buffer, ct.Token);
Assert.IsTrue(result.EndOfMessage, "End of message is true");
Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME", "Final message is WELCOME");
#else
var clientSocket = new WebSocket(wsUrl);
clientSocket.Connect();
Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open");
clientSocket.Send("HOLA");
await Task.Delay(100);
#endif
}