static void Main(String[] args)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
var endpoint = new IPEndPoint(IPAddress.Any, 8001);
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions() { SubProtocols = new[] {"chat"} });
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
server.Standards.RegisterStandard(rfc6455);
server.Start();
Log("Rx Chat Server started at " + endpoint.ToString());
var chatSessionObserver = new ChatSessionsObserver(new ChatRoomManager());
Observable.FromAsync(server.AcceptWebSocketAsync)
.Select(ws => new ChatSession(ws)
{
In = Observable.FromAsync<dynamic>(ws.ReadDynamicAsync)
.DoWhile(() => ws.IsConnected)
.Where(msg => msg != null),
Out = Observer.Create<dynamic>(ws.WriteDynamic)
})
.DoWhile(() => server.IsStarted && !cancellation.IsCancellationRequested)
.Subscribe(chatSessionObserver);
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
Console.ReadKey(true);
}
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();
}
private void setRFC6455ServerStandards()
{
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
server.Standards.RegisterStandard(rfc6455);
}
static void Main(string[] args)
{
if (PerformanceCounters.CreatePerformanceCounters())
{
return;
}
// reseting peformance counter
PerformanceCounters.Connected.RawValue = 0;
// configuring logging
log4net.Config.XmlConfigurator.Configure();
_log.Info("Starting Echo Server");
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
// opening TLS certificate
//X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
//store.Open(OpenFlags.ReadOnly);
//store.Certificates.Count.ToString();
//var certificate = store.Certificates[1];
//store.Close();
CancellationTokenSource cancellation = new CancellationTokenSource();
// local endpoint
var endpoint = new IPEndPoint(IPAddress.Any, 8005);
// starting the server
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
SubProtocols = new [] { "text" },
PingTimeout = TimeSpan.FromSeconds(5),
NegotiationTimeout = TimeSpan.FromSeconds(5),
ParallelNegotiations = 16,
NegotiationQueueCapacity = 256,
TcpBacklog = 1000,
BufferManager = BufferManager.CreateBufferManager((8192 + 1024) * 1000, 8192 + 1024)
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
// adding the deflate extension
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
server.Standards.RegisterStandard(rfc6455);
// adding the WSS extension
//server.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(certificate));
server.Start();
Log("Echo Server started at " + endpoint.ToString());
var acceptingTask = Task.Run(() => AcceptWebSocketClients(server, cancellation.Token));
Console.ReadKey(true);
Log("Server stoping");
server.Stop();
cancellation.Cancel();
acceptingTask.Wait();
Console.ReadKey(true);
}
private void Run(string[] args)
{
var host = ConfigurationManager.AppSettings["BroadcastServerHost"];
var port = Convert.ToInt32(ConfigurationManager.AppSettings["BroadcastServerPort"]);
CancellationTokenSource cancellation = new CancellationTokenSource();
var endpoint = new IPEndPoint(host.Trim().ToLower() == "*" ? IPAddress.Any : IPAddress.Parse(host), port);
WebSocketListener server = new WebSocketListener(endpoint);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
server.Start();
Console.WriteLine($"{this.GetType().Namespace} on host {endpoint.ToString()}");
var task = Task.Run(() => AcceptWebSocketClientsAsync(server, cancellation.Token));
Console.WriteLine("Press Ctrl-C to quit");
var exitEvent = new ManualResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
exitEvent.Set();
};
exitEvent.WaitOne();
// cancel socket server and wait for completion
cancellation.Cancel();
task.Wait();
}
public void RunServer()
{
var server = new WebSocketListener(new IPEndPoint(IPAddress.Any, 8006));
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
server.Start();
}
static void Main(string[] args)
{
if (PerformanceCounters.CreatePerformanceCounters())
return;
// reseting peformance counter
PerformanceCounters.Connected.RawValue = 0;
// configuring logging
log4net.Config.XmlConfigurator.Configure();
_log.Info("Starting Echo Server");
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
// opening TLS certificate
X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly);
store.Certificates.Count.ToString();
var certificate = store.Certificates[1];
store.Close();
CancellationTokenSource cancellation = new CancellationTokenSource();
// local endpoint
var endpoint = new IPEndPoint(IPAddress.Any, 8006);
// starting the server
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
SubProtocols = new []{"text"},
PingTimeout = TimeSpan.FromSeconds(5),
NegotiationTimeout = TimeSpan.FromSeconds(5),
ParallelNegotiations = 16,
NegotiationQueueCapacity = 256,
TcpBacklog = 1000,
BufferManager = BufferManager.CreateBufferManager((8192 + 1024)*1000, 8192 + 1024)
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
// adding the deflate extension
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
server.Standards.RegisterStandard(rfc6455);
// adding the WSS extension
server.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(certificate));
server.Start();
Log("Echo Server started at " + endpoint.ToString());
var acceptingTask = Task.Run(()=> AcceptWebSocketClients(server, cancellation.Token));
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
acceptingTask.Wait();
Console.ReadKey(true);
}
protected override void OnStart(string[] args)
{
_cancellation = new CancellationTokenSource();
_listener = new WebSocketListener(new IPEndPoint(IPAddress.Any, _port));
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_listener);
_listener.Standards.RegisterStandard(rfc6455);
var task = Task.Run(() => AcceptWebSocketClientsAsync(_listener, _cancellation.Token));
_listener.Start();
}
protected override void OnStart(string[] args)
{
_cancellation = new CancellationTokenSource();
_listener = new WebSocketListener(new IPEndPoint(IPAddress.Any, _port));
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_listener);
_listener.Standards.RegisterStandard(rfc6455);
var task = Task.Run(() => AcceptWebSocketClientsAsync(_listener, _cancellation.Token));
_listener.Start();
}
public static void Main(string[] args)
{
var certificate_path = ConfigurationManager.AppSettings ["CertificatePath"];
var certificate_password = ConfigurationManager.AppSettings["CertificatePassword"];
SignallingManager.TurnServer = ConfigurationManager.AppSettings["TurnServer"];
SignallingManager.TurnServerUsername = ConfigurationManager.AppSettings["TurnServerUsername"];
SignallingManager.TurnServerPassword = ConfigurationManager.AppSettings["TurnServerPassword"];
string server_type = ConfigurationManager.AppSettings ["ServerType"];
X509Certificate2 certificate = (!string.IsNullOrEmpty(certificate_path) && !string.IsNullOrEmpty(certificate_password)) ? new X509Certificate2(certificate_path, certificate_password) : null;
IPAddress ip = IPAddress.None;
CancellationTokenSource cancellation = new CancellationTokenSource();
if (server_type.ToLower().Equals("internal"))
{
ip = IPAddress.Parse("127.0.0.1");
}
else if (server_type.ToLower().Equals("external"))
{
ip = IPAddress.Any;
}
var endpoint = new IPEndPoint(ip, ushort.Parse(ConfigurationManager.AppSettings["ServerPort"]));
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
SubProtocols = new [] { "text" }
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
if (certificate != null)
{
Log("SSL is on");
server.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(certificate));
}
server.Start();
Log("Server started at " + endpoint.ToString());
var task = Task.Run(() => AcceptWebSocketClientsAsync(server, cancellation.Token));
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
task.Wait();
Console.ReadKey(true);
}
public void Start()
{
attackerQueue = new Queue<String>();
defenderQueue = new Queue<String>();
wsToIdDictionary = new Dictionary<WebSocket, String>();
idToPlayerDictionary = new Dictionary<String, Player>();
cancellation = new CancellationTokenSource();
IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8005);
server = new WebSocketListener(endpoint);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
server.Start();
Console.WriteLine("Echo Server started at " + endpoint.ToString());
var task = Task.Run(() => AcceptWebSocketClientsAsync(server, cancellation.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 WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <IMyService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
{
Thread.Sleep(10);
}
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public static void Main (string[] args)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
var endpoint = new IPEndPoint(IPAddress.Any, 8005);
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions(){ SubProtocols = new []{"text"}});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
server.Start();
Log("Mono Echo Server started at " + endpoint.ToString());
var task = Task.Run(() => AcceptWebSocketClientsAsync(server, cancellation.Token));
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
task.Wait();
Console.ReadKey(true);
}
public WebSocketQueueServer(IPEndPoint endpoint, ISystemInfo sysinfo, ILogger log)
{
_log = log;
_sysInfo = sysinfo;
_cancellation = new CancellationTokenSource();
_serializator = new DefaultEventSerializator();
Queue = ServiceBusFactory.New(sbc =>
{
sbc.UseBinarySerializer();
sbc.ReceiveFrom("loopback://localhost/queue");
});
_wsServer = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan,
OnHttpNegotiation = HttpNegotiation
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_wsServer);
_wsServer.Standards.RegisterStandard(rfc6455);
}
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 void StartServer([NotNull] IButtplugServiceFactory aFactory, int aPort = 12345, bool aSecure = false)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
_factory = aFactory;
var endpoint = new IPEndPoint(IPAddress.Any, aPort);
_server = new WebSocketListener(endpoint);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_server);
_server.Standards.RegisterStandard(rfc6455);
if (aSecure)
{
var cert = CertUtils.GetCert("B******g");
_server.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(cert));
}
_server.Start();
Task.Run(() => AcceptWebSocketClientsAsync(_server, cancellation.Token));
}
public MainWindow()
{
InitializeComponent();
try
{
_tockenSource = new CancellationTokenSource();
_users = new List <ChatUser>();
_ipEndPoint = new IPEndPoint(IPAddress.Parse(ConfigurationManager.AppSettings["ipAddress"]),
Convert.ToInt32(ConfigurationManager.AppSettings["port"]));
_webSocketListener = new WebSocketListener(_ipEndPoint);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_webSocketListener);
_webSocketListener.Standards.RegisterStandard(rfc6455);
_webSocketListener.Start();
}
catch (Exception exception)
{
LogsTextBox.Text += $"[{DateTime.Now}] {exception.Message}\r\n";
}
}
public WebSocketQueueServer(IPEndPoint endpoint, ISystemInfo sysinfo, ILogger log)
{
_log = log;
_sysInfo = sysinfo;
_cancellation = new CancellationTokenSource();
_serializator = new DefaultEventSerializator();
Queue = ServiceBusFactory.New(sbc =>
{
sbc.UseBinarySerializer();
sbc.ReceiveFrom("loopback://localhost/queue");
});
_wsServer = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
PingTimeout = Timeout.InfiniteTimeSpan,
OnHttpNegotiation = HttpNegotiation
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_wsServer);
_wsServer.Standards.RegisterStandard(rfc6455);
}
static void Main(String[] args)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
var endpoint = new IPEndPoint(IPAddress.Any, 8001);
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
SubProtocols = new[] { "chat" }
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
server.Standards.RegisterStandard(rfc6455);
server.Start();
Log("Rx Chat Server started at " + endpoint.ToString());
var chatSessionObserver = new ChatSessionsObserver(new ChatRoomManager());
Observable.FromAsync(server.AcceptWebSocketAsync)
.Select(ws => new ChatSession(ws)
{
In = Observable.FromAsync <dynamic>(ws.ReadDynamicAsync)
.DoWhile(() => ws.IsConnected)
.Where(msg => msg != null),
Out = Observer.Create <dynamic>(ws.WriteDynamic)
})
.DoWhile(() => server.IsStarted && !cancellation.IsCancellationRequested)
.Subscribe(chatSessionObserver);
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
Console.ReadKey(true);
}
public void StartServer([NotNull] IButtplugServerFactory aFactory, int aPort = 12345, bool aLoopBack = true, bool aSecure = false, string aHostname = "localhost")
{
_cancellation = new CancellationTokenSource();
_factory = aFactory;
_logManager = new ButtplugLogManager();
_logger = _logManager.GetLogger(this.GetType());
var endpoint = new IPEndPoint(aLoopBack ? IPAddress.Loopback : IPAddress.Any, aPort);
_server = new WebSocketListener(endpoint);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_server);
_server.Standards.RegisterStandard(rfc6455);
if (aSecure)
{
var cert = CertUtils.GetCert("B******g", aHostname);
_server.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(cert));
}
_server.Start();
Task.Run(() => AcceptWebSocketClientsAsync(_server, _cancellation.Token));
}
public static void Main(string[] args)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
var endpoint = new IPEndPoint(IPAddress.Any, 8005);
WebSocketListener server = new WebSocketListener(endpoint, new WebSocketListenerOptions()
{
SubProtocols = new [] { "text" }
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(server);
server.Standards.RegisterStandard(rfc6455);
server.Start();
Log("Mono Echo Server started at " + endpoint.ToString());
var task = Task.Run(() => AcceptWebSocketClientsAsync(server, cancellation.Token));
Console.ReadKey(true);
Log("Server stoping");
cancellation.Cancel();
task.Wait();
Console.ReadKey(true);
}
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 WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<IMyService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
Thread.Sleep(10);
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public void Open()
{
IPAddress ipAddress = IPAddress.Any;
if (_endPointUri.IsLoopback)
{
ipAddress = IPAddress.Loopback;
}
else if (!"0.0.0.0".Equals(_endPointUri.DnsSafeHost))
{
ipAddress = IOUtil.GetIPAddress(_endPointUri.DnsSafeHost);
}
var options = new WebSocketListenerOptions()
{
NegotiationQueueCapacity = 128,
ParallelNegotiations = 16,
PingTimeout = Timeout.InfiniteTimeSpan,
SubProtocols = new[] {"v1.openicf.forgerock.org"},
OnHttpNegotiation = (request, response) =>
{
var authHeader = request.Headers["Authorization"];
if (authHeader != null)
{
var authHeaderVal = AuthenticationHeaderValue.Parse(authHeader);
// RFC 2617 sec 1.2, "scheme" name is case-insensitive
if (authHeaderVal.Scheme.Equals("basic",
StringComparison.OrdinalIgnoreCase) &&
authHeaderVal.Parameter != null)
{
var encoding = Encoding.GetEncoding("iso-8859-1");
var credentials = encoding.GetString(Convert.FromBase64String(authHeaderVal.Parameter));
int separator = credentials.IndexOf(':');
if (separator != -1)
{
string name = credentials.Substring(0, separator);
string password = credentials.Substring(separator + 1);
var pair = _validator.FindPrincipal(name);
if (null != pair)
{
if (ClientAuthenticationValidator.Verify(pair.Second, password))
{
request.Items["ConnectionPrincipal"] = pair.First;
}
else
{
Trace.TraceWarning("Incorrect password - username: {0}", name);
response.Status = HttpStatusCode.Forbidden;
}
}
else
{
Trace.TraceWarning("Unknown username: {0}", name);
response.Status = HttpStatusCode.Forbidden;
}
}
else
{
Trace.TraceWarning("Invalid Basic Authorization : {0}", credentials);
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
Trace.TraceWarning("Basic Authorization header expected but found{0}", authHeader);
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
//401 + Realm
response.Status = HttpStatusCode.Unauthorized;
}
}
};
_listener = new WebSocketListener(new IPEndPoint(ipAddress, _endPointUri.Port), options);
bool useSsl = String.Equals("https", _endPointUri.Scheme, StringComparison.OrdinalIgnoreCase) ||
String.Equals("wss", _endPointUri.Scheme, StringComparison.OrdinalIgnoreCase);
if (useSsl)
{
_listener.ConnectionExtensions.RegisterExtension(
new WebSocketSecureConnectionExtension(GetCertificate()));
}
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_listener);
_listener.Standards.RegisterStandard(rfc6455);
_listener.Start();
Task.Run((Func<Task>) ListenAsync);
}
public void Benchmark()
{
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<ISumService>(new SumService());
listener.Start();
var client = new WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<ISumService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
Thread.Sleep(10);
const int randCnt = 100;
var rand = new Random(42);
var randoms = new int[randCnt];
for (int i = 0; i < randCnt; i++) randoms[i] = rand.Next(10000000, 20000000);
var sw = new Stopwatch();
long timeFromClient = 0, timeToClient = 0;
const int cnt = 1000;
for (int j = 0; j < cnt; j++)
{
sw.Start();
var sum = proxy.Sum(randoms).Result;
sw.Stop();
Assert.Equal(randoms.Sum(), sum);
for (int i = 0; i < randCnt; i++) randoms[i] = rand.Next(10000000, 20000000);
var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
timeFromClient += times.Item1;
timeToClient += Stopwatch.GetTimestamp() - times.Item2;
}
_testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
_testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
_testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);
//sw.Reset();
//var tree = new SumServiceTree();
//SumServiceTree.FillTree(tree, rand, 2);
//_testOutputHelper.WriteLine("Starting large message transfer.");
//sw.Start();
//var result = proxy.Increment(tree).Result;
//sw.Stop();
//Assert.Equal(tree.Leaf + 1, result.Leaf);
//_testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public void Benchmark()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(30000, 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 <ISumService>(new SumService());
listener.Start();
var client = new ClientWebSocket();
client.Options.AddSubProtocol("SignalR");
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <ISumService>();
client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();
const int randCnt = 100;
var rand = new Random(42);
var randoms = new int[randCnt];
for (int i = 0; i < randCnt; i++)
{
randoms[i] = rand.Next(10000000, 20000000);
}
var sw = new Stopwatch();
long timeFromClient = 0, timeToClient = 0;
const int cnt = 1000;
for (int j = 0; j < cnt; j++)
{
sw.Start();
var sum = proxy.Sum(randoms).Result;
sw.Stop();
Assert.Equal(randoms.Sum(), sum);
for (int i = 0; i < randCnt; i++)
{
randoms[i] = rand.Next(10000000, 20000000);
}
var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
timeFromClient += times.Item1;
timeToClient += Stopwatch.GetTimestamp() - times.Item2;
}
_testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
_testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
_testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);
sw.Reset();
var tree = new SumServiceTree();
SumServiceTree.FillTree(tree, rand, 2);
_testOutputHelper.WriteLine("Starting large message transfer.");
sw.Start();
var result = proxy.Increment(tree).Result;
sw.Stop();
Assert.Equal(tree.Leaf + 1, result.Leaf);
_testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public async Task StartAsync()
{
await _semaphore.WaitAsync();
try
{
if (_webSocketListener != null)
{
throw new InvalidOperationException("The listener is already active");
}
var listenerUri = ListenerUris[0];
IPEndPoint listenerEndPoint;
if (listenerUri.IsLoopback)
{
listenerEndPoint = new IPEndPoint(IPAddress.Any, listenerUri.Port);
}
else
{
switch (listenerUri.HostNameType)
{
case UriHostNameType.Dns:
var dnsEntry = await Dns.GetHostEntryAsync(listenerUri.Host).ConfigureAwait(false);
if (dnsEntry.AddressList.Any(a => a.AddressFamily == AddressFamily.InterNetwork))
{
listenerEndPoint =
new IPEndPoint(
dnsEntry.AddressList.First(a => a.AddressFamily == AddressFamily.InterNetwork),
listenerUri.Port);
}
else
{
throw new ArgumentException(
$"Could not resolve the IPAddress for the host '{listenerUri.Host}'");
}
break;
case UriHostNameType.IPv4:
case UriHostNameType.IPv6:
listenerEndPoint = new IPEndPoint(IPAddress.Parse(listenerUri.Host), listenerUri.Port);
break;
default:
throw new ArgumentException($"The host name type for '{listenerUri.Host}' is not supported");
}
}
_webSocketListener = new WebSocketListener(
listenerEndPoint,
new WebSocketListenerOptions()
{
SubProtocols = new[] { LimeUri.LIME_URI_SCHEME }
});
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_webSocketListener);
_webSocketListener.Standards.RegisterStandard(rfc6455);
if (_sslCertificate != null)
{
_webSocketListener.ConnectionExtensions.RegisterExtension(
new WebSocketSecureConnectionExtension(_sslCertificate));
}
_webSocketListener.Start();
}
finally
{
_semaphore.Release();
}
}
