private async Task <GameSocket> AcceptGameSocketAsync(GameSocketAcceptContext context)
{
IDictionary <string, object> options = null;
if (context is OwinGameSocketAcceptContext)
{
var acceptContext = context as OwinGameSocketAcceptContext;
options = acceptContext.Options;
_subProtocol = acceptContext.SubProtocol;
}
else if (context?.SubProtocol != null)
{
options = new Dictionary <string, object>(1)
{
{ OwinConstants.GameSocket.SubProtocol, context.SubProtocol }
};
_subProtocol = context.SubProtocol;
}
// Accept may have been called synchronously on the original request thread, we might not have a task yet. Go async.
await _upstreamWentAsync.Task;
_owinGameSocketAccept(options, OwinAcceptCallback);
_requestTcs.TrySetResult(0); // Let the pipeline unwind.
return(await _acceptTcs.Task);
}
public async Task <WebSocket> AcceptAsync(GameSocketAcceptContext acceptContext)
{
if (!IsGameSocketRequest)
{
throw new InvalidOperationException("Not a WebSocket request."); // TODO: LOC
}
var subProtocol = acceptContext?.SubProtocol;
var keepAliveInterval = _options.KeepAliveInterval;
var receiveBufferSize = _options.ReceiveBufferSize;
if (acceptContext is ExtendedGameSocketAcceptContext advancedAcceptContext)
{
if (advancedAcceptContext.ReceiveBufferSize.HasValue)
{
receiveBufferSize = advancedAcceptContext.ReceiveBufferSize.Value;
}
if (advancedAcceptContext.KeepAliveInterval.HasValue)
{
keepAliveInterval = advancedAcceptContext.KeepAliveInterval.Value;
}
}
var key = string.Join(", ", _context.Request.Headers[Constants.Headers.SecGameSocketKey]);
HandshakeHelpers.GenerateResponseHeaders(key, subProtocol, _context.Response.Headers);
var opaqueTransport = await _upgradeFeature.UpgradeAsync(); // Sets status code to 101
return(WebSocket.CreateFromStream(opaqueTransport, isServer: true, subProtocol: subProtocol, keepAliveInterval: keepAliveInterval));
}
Task <GameSocket> IProtoGameSocketFeature.AcceptAsync(GameSocketAcceptContext context)
{
object obj;
if (!Environment.TryGetValue(OwinConstants.GameSocket.AcceptAlt, out obj))
{
throw new NotSupportedException("GameSockets are not supported"); // TODO: LOC
}
var accept = (Func <GameSocketAcceptContext, Task <GameSocket> >)obj;
return(accept(context));
}
async Task <GameSocket> IProtoGameSocketFeature.AcceptAsync(GameSocketAcceptContext context)
{
var gamesockets = TestGameSocket.CreatePair(context.SubProtocol);
if (_httpContext.Response.HasStarted)
{
throw new InvalidOperationException("The response has already started");
}
_httpContext.Response.StatusCode = StatusCodes.Status101SwitchingProtocols;
ClientGameSocket = gamesockets.Item1;
ServerGameSocket = gamesockets.Item2;
await _httpContext.Response.Body.FlushAsync(_httpContext.RequestAborted); // Send headers to the client
return(ServerGameSocket);
}
public static AppFunc AdaptGameSockets(AppFunc next)
{
return(async environment =>
{
object accept;
if (environment.TryGetValue(OwinConstants.GameSocket.AcceptAlt, out accept) && accept is GameSocketAcceptAlt)
{
var adapter = new GameSocketAcceptAdapter(environment, (GameSocketAcceptAlt)accept);
environment[OwinConstants.GameSocket.Accept] = new GameSocketAccept(adapter.AcceptGameSocket);
await next(environment);
if ((int)environment[OwinConstants.ResponseStatusCode] == 101 && adapter._callback != null)
{
GameSocketAcceptContext acceptContext = null;
object obj;
if (adapter._options != null && adapter._options.TryGetValue(typeof(GameSocketAcceptContext).FullName, out obj))
{
acceptContext = obj as GameSocketAcceptContext;
}
else if (adapter._options != null)
{
acceptContext = new OwinGameSocketAcceptContext(adapter._options);
}
var gameSocket = await adapter._accept(acceptContext);
var gameSocketAdapter = new GameSocketAdapter(gameSocket, (CancellationToken)environment[OwinConstants.CallCancelled]);
await adapter._callback(gameSocketAdapter.Environment);
await gameSocketAdapter.CleanupAsync();
}
}
else
{
await next(environment);
}
});
}
