public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest || context.IsWebSocketRequestUpgrading)
{
context.AcceptWebSocketRequest(new Broadcaster());
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(new MicrosoftWebSockets());
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
context.AcceptWebSocketRequest(this.HandleWebSocket);
else
context.Response.StatusCode = 400;
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
context.AcceptWebSocketRequest(new ChatWebsocket());
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest || context.IsWebSocketRequestUpgrading)
{
context.AcceptWebSocketRequest(new G_Location_Handler());
}
}
/// <summary>
/// Process the request.
/// </summary>
/// <param name="httpContext">The http context.</param>
private void ProcessWebSocketRequest(System.Web.HttpContext httpContext)
{
HttpResponse response = null;
try
{
// Get the request and response context.
response = httpContext.Response;
// Process the request asynchronously.
httpContext.AcceptWebSocketRequest(ProcessWebSocketRequestAsync);
}
catch (Exception)
{
try
{
if (response != null)
{
// Get the response OutputStream and write the response to it.
response.AddHeader("Content-Length", (0).ToString());
response.StatusCode = (int)HttpStatusCode.InternalServerError;
response.StatusDescription = "Internal Server Error";
response.Close();
}
}
catch { }
}
}
public override async Task ProcessRequestAsync(HttpContext context)
{
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(WebSocketHandler);
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(ProcessWS);
}
}
public void ProcessRequest(HttpContext context)
{
context.AcceptWebSocketRequest(async sc =>
{
var socket = sc.WebSocket;
while(true)
{
var buffer = new ArraySegment<byte>(new byte[1024]);
await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
var message = Encoding.UTF8.GetString(buffer.Array, 0, buffer.Count);
var response = "Hello from WebSockets, " + message + ". The time is: " + DateTime.Now.ToShortTimeString();
var responseBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(response));
for (var i = 0; i < 5; i++)
{
var q = new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello " + i));
await socket.SendAsync(q, WebSocketMessageType.Text, true, CancellationToken.None);
Thread.Sleep(2000);
}
await socket.SendAsync(responseBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
break;
}
}
});
}
public void ProcessRequest(HttpContext context)
{
bool isSocket = false;
WebSupport.InitializeContextStorage(context.Request);
if (context.IsWebSocketRequest)
{
isSocket = true;
}
if (context.IsWebSocketRequest)
context.AcceptWebSocketRequest(HandleWebSocket);
else
HandleNonWebsocketRequest(context);
/*
WebSupport.InitializeContextStorage(context.Request);
try
{
if (request.Path.StartsWith(AuthEmailValidation))
{
HandleEmailValidation(context);
}
} finally
{
InformationContext.ProcessAndClearCurrent();
}*/
}
public void ProcessRequest(HttpContext context)
{
ClearExpiredSocket();
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(ProcessChat);
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
var player = new GamePlayer();
FourInABruGame.Join(player);
context.AcceptWebSocketRequest(player.SocketReceiver);
}
}
public void ProcessRequest(HttpContext context)
{
var user = context.Request.Cookies["username"].Value;
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(new ChatHandler(user));
}
}
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
context.Response.Write("Hello World");
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(new SocketHandler());
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(new WebSocketsAPIHandler());
}
else
{
context.Response.ContentType = "text/plain";
context.Response.Write("Not WebSockets");
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
// create a player
var player = new PongPlayer();
PongApp.JoinPlayer(player);
// start receiving from socket
context.AcceptWebSocketRequest(player.Receiver);
}
}
public void ProcessRequest(HttpContext context)
{
try
{
context.AcceptWebSocketRequest(WebSocketLoop);
}
catch (Exception ex)
{
Trace.WriteLine(ex);
context.Response.StatusCode = 500;
context.Response.End();
}
}
public void ProcessRequest(HttpContext context)
{
string subProtocol = context.Request.QueryString["subprotocol"];
if (context.Request.Url.Query == "?delay10sec")
{
Thread.Sleep(10000);
}
try
{
if (!context.IsWebSocketRequest)
{
context.Response.StatusCode = 200;
context.Response.ContentType = "text/plain";
context.Response.Write("Not a websocket request");
return;
}
if (!string.IsNullOrEmpty(subProtocol))
{
var wsOptions = new AspNetWebSocketOptions();
wsOptions.SubProtocol = subProtocol;
context.AcceptWebSocketRequest(ProcessWebSocketRequest, wsOptions);
}
else
{
context.AcceptWebSocketRequest(ProcessWebSocketRequest);
}
}
catch (Exception ex)
{
context.Response.StatusCode = 500;
context.Response.StatusDescription = ex.Message;
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
{
var name = context.Request.QueryString["Name"];
var participant = new Participant(name);
participant.MessageReceived += OnParticipantMessageReceived;
participant.Disconnected += OnParticipantDisconnected;
participants.Add(participant);
context.AcceptWebSocketRequest(participant.Receiver);
}
}
public void ProcessRequest(HttpContext context)
{
try
{
if (context.IsWebSocketRequest)
context.AcceptWebSocketRequest(HandleWebSocket);
else
context.Response.StatusCode = 400;
}
catch (Exception ex)
{
context.Response.StatusCode = 500;
context.Response.StatusDescription = ex.Message;
context.Response.End();
}
}
public void ProcessRequest(HttpContext context) {
if (context.IsWebSocketRequest) {
context.AcceptWebSocketRequest(WebSocketRequestHandler);
} else {
context.Response.ContentType = "text/html";
context.Response.ContentEncoding = Encoding.UTF8;
switch (context.Request.QueryString["debug"]) {
case "startlog":
_log = new StringWriter();
context.Response.Write("Logging is now enabled. <a href='?debug=viewlog'>View</a>. <a href='?debug=stoplog'>Disable</a>.");
return;
case "stoplog":
_log = null;
context.Response.Write("Logging is now disabled. <a href='?debug=startlog'>Enable</a>.");
return;
case "clearlog": {
var log = _log;
if (log != null) {
log.GetStringBuilder().Clear();
}
context.Response.Write("Log is cleared. <a href='?debug=viewlog'>View</a>.");
return;
}
case "viewlog": {
var log = _log;
if (log == null) {
context.Response.Write("Logging is disabled. <a href='?debug=startlog'>Enable</a>.");
} else {
context.Response.Write("Logging is enabled. <a href='?debug=clearlog'>Clear</a>. <a href='?debug=stoplog'>Disable</a>. <p><pre>");
context.Response.Write(HttpUtility.HtmlDecode(log.ToString()));
context.Response.Write("</pre>");
}
context.Response.End();
return;
}
}
ProcessHelpPageRequest(context);
}
}
public override Task ProcessRequestAsync(HttpContext context)
{
context.AcceptWebSocketRequest(socketContext =>
{
try
{
Foo();
}
catch(Exception ex)
{
// The exception is thrown here, we're just sending the message back to the socket
// so we can disply something in the client.
return socketContext.WebSocket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(ex.Message)), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None);
}
return Task.FromResult(0);
});
return Task.FromResult(0);
}
public void ProcessRequest(HttpContext context)
{
try
{
if (!context.IsWebSocketRequest)
{
context.Response.StatusCode = 200;
context.Response.ContentType = "text/plain";
context.Response.Write("Not a websocket request");
return;
}
context.AcceptWebSocketRequest(ProcessWebSocketRequest);
}
catch (Exception ex)
{
context.Response.StatusCode = 500;
context.Response.StatusDescription = ex.Message;
}
}
public void ProcessRequest(HttpContext context)
{
_Log.Trace("Started");
_Log.Debug("entering ProcessRequest");
try
{
string AgentId = context.Request.QueryString["agentId"] != null ? context.Request.QueryString["agentId"] : "";
string OrgId = context.Request.QueryString["orgId"] != null ? context.Request.QueryString["orgId"] : "";
_Log.Debug("OrgId : " + OrgId + ", AgentId : " + AgentId);
if (context.IsWebSocketRequest || context.IsWebSocketRequestUpgrading)
{
context.AcceptWebSocketRequest(new AgentPopupWebSocketHandler(OrgId, AgentId));
}
}
catch (Exception ex)
{
_Log.Error(ex.Message, ex);
throw;
}
_Log.Trace("Ended");
}
public void ProcessRequest(HttpContext context)
{
context.AcceptWebSocketRequest(WebSocketProcessRequest);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void ProcessRequest(HttpContext context)
{
try
{
context.AcceptWebSocketRequest(async wsContext =>
{
try
{
byte[] receiveBuffer = new byte[MaxBufferSize];
ArraySegment<byte> buffer = new ArraySegment<byte>(receiveBuffer);
WebSocket socket = wsContext.WebSocket;
string userString;
if (socket.State == WebSocketState.Open)
{
// Announcement when connected
var announceString = "EchoWebSocket Connected at: " + DateTime.Now.ToString();
ArraySegment<byte> outputBuffer2 = new ArraySegment<byte>(Encoding.UTF8.GetBytes(announceString));
await socket.SendAsync(outputBuffer2, WebSocketMessageType.Text, true, CancellationToken.None);
}
// Stay in loop while websocket is open
while (socket.State == WebSocketState.Open)
{
WebSocketReceiveResult receiveResult = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (receiveResult.MessageType == WebSocketMessageType.Close)
{
// Echo back code and reason strings
await socket.CloseAsync(
receiveResult.CloseStatus.GetValueOrDefault(),
receiveResult.CloseStatusDescription,
CancellationToken.None);
return;
}
int offset = receiveResult.Count;
while (receiveResult.EndOfMessage == false)
{
receiveResult = await socket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer, offset, MaxBufferSize - offset), CancellationToken.None);
offset += receiveResult.Count;
}
if (receiveResult.MessageType == WebSocketMessageType.Text)
{
string cmdString = Encoding.UTF8.GetString(receiveBuffer, 0, offset);
userString = cmdString;
userString = "You said: \"" + userString + "\"";
ArraySegment<byte> outputBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userString));
await socket.SendAsync(outputBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else if (receiveResult.MessageType == WebSocketMessageType.Binary)
{
userString = String.Format("binary message received, size={0} bytes", receiveResult.Count);
ArraySegment<byte> outputBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userString));
await socket.SendAsync(outputBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex);
}
});
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex);
context.Response.StatusCode = 500;
context.Response.StatusDescription = ex.Message;
context.Response.End();
}
}
public void ProcessRequest(HttpContext context)
{
context.AcceptWebSocketRequest(new WebSocketListener());
}
public override void AcceptWebSocketRequest(Func <AspNetWebSocketContext, Task> userFunc)
{
_context.AcceptWebSocketRequest(userFunc);
}
public void ProcessRequest(HttpContext context)
{
context.AcceptWebSocketRequest(new EchoWebSocketHandler());
}
public override async Task ProcessRequestAsync(HttpContext httpContext)
{
await Task.Run(() =>
{
if (httpContext.IsWebSocketRequest)
{
httpContext.AcceptWebSocketRequest(async delegate(AspNetWebSocketContext context)
{
this.Socket = context.WebSocket;
while (this.Socket != null || this.Socket.State != WebSocketState.Closed)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult receiveResult = await this.Socket.ReceiveAsync(buffer, CancellationToken.None);
try
{
switch (receiveResult.MessageType)
{
case WebSocketMessageType.Text:
string message = Encoding.UTF8.GetString(buffer.Array, 0, receiveResult.Count);
this.OnMessageReceived(message);
break;
case WebSocketMessageType.Binary:
this.OnMessageReceived(buffer.Array);
break;
case WebSocketMessageType.Close:
this.OnClosing(true, receiveResult.CloseStatusDescription);
break;
}
switch (this.Socket.State)
{
case WebSocketState.Connecting:
this.OnConnecting();
break;
case WebSocketState.Open:
this.OnOpen();
break;
case WebSocketState.CloseSent:
this.OnClosing(false, string.Empty);
break;
case WebSocketState.CloseReceived:
this.OnClosing(true, string.Empty);
break;
case WebSocketState.Closed:
this.OnClosed();
break;
}
}
catch (Exception ex)
{
this.OnError(ex);
}
}
});
}
});
}
public override async Task ProcessRequestAsync(HttpContext httpContext)
{
string logStr = this.ToString() + ":" + MethodBase.GetCurrentMethod().Name + " ";
Trace.WriteLine(logStr + "Enter");
try
{
await Task.Run(() =>
{
try
{
if (httpContext.IsWebSocketRequest || httpContext.IsWebSocketRequestUpgrading)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[512]);
httpContext.AcceptWebSocketRequest(async delegate(AspNetWebSocketContext aspNetWebSocketContext)
{
var socket = aspNetWebSocketContext.WebSocket;
var sbMsg = new StringBuilder();
//Checks if the connection is not already closed
while (socket != null || socket.State != WebSocketState.Closed)
{
WebSocketReceiveResult receiveResult = await socket.ReceiveAsync(buffer, CancellationToken.None);
switch (receiveResult.MessageType)
{
case WebSocketMessageType.Text:
string message = Encoding.UTF8.GetString(buffer.Array, 0, receiveResult.Count);
sbMsg.Append(message);
if (!receiveResult.EndOfMessage)
continue;
string finalMessage = sbMsg.ToString();
_clientId = int.Parse(finalMessage.Split('~')[1]);
Trace.WriteLine(logStr + "finalMessage: " + finalMessage);
sbMsg.Clear();
var socketSend = socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
await socketSend;
break;
case WebSocketMessageType.Binary:
Trace.WriteLine(logStr + "binary data received");
break;
case WebSocketMessageType.Close:
Trace.WriteLine(logStr + "msg type close received");
break;
}
switch (socket.State)
{
case WebSocketState.Connecting:
this.OnConnecting();
break;
case WebSocketState.Open:
this.OnOpen();
break;
case WebSocketState.CloseSent:
case WebSocketState.CloseReceived:
case WebSocketState.Closed:
this.OnClosed();
break;
case WebSocketState.Aborted:
this.OnAbort();
break;
}
}
Trace.WriteLine(logStr + "Socket closed");
});
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message + ex.StackTrace);
}
});
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message + ex.StackTrace);
}
}
public void ProcessRequest(HttpContext context)
{
if (context.IsWebSocketRequest)
context.AcceptWebSocketRequest(new WebSocketChatHandler());
}
