internal IHttpRequestReponse Parse(HttpParserDelegate requestHandler, Stream stream, TimeSpan timeout)
{
using (var parserHandler = new HttpCombinedParser(requestHandler))
{
var observeRequstStream = new ObservableHttpData().Create(requestHandler.HttpRequestReponse, stream, timeout);
var observerRequestSubscriber = observeRequstStream.Subscribe(
bArray =>
{
try
{
if (parserHandler.Execute(new ArraySegment <byte>(bArray, 0, bArray.Length)) <= 0)
{
requestHandler.HttpRequestReponse.IsUnableToParseHttp = true;
}
}
catch (Exception)
{
requestHandler.HttpRequestReponse.IsUnableToParseHttp = true;
}
},
ex =>
{
if (ex is TimeoutException)
{
requestHandler = new HttpParserDelegate
{
HttpRequestReponse =
{
IsRequestTimedOut = true
}
};
}
else
{
requestHandler = new HttpParserDelegate
{
HttpRequestReponse =
{
IsUnableToParseHttp = true
}
};
}
},
() =>
{
});
observerRequestSubscriber.Dispose();
parserHandler.Execute(default(ArraySegment <byte>));
requestHandler.HttpRequestReponse.MajorVersion = parserHandler.MajorVersion;
requestHandler.HttpRequestReponse.MinorVersion = parserHandler.MinorVersion;
requestHandler.HttpRequestReponse.ShouldKeepAlive = parserHandler.ShouldKeepAlive;
}
return(requestHandler.HttpRequestReponse);
}
static void Main(string[] args)
{
var handler = new ParserHandler();
var parser = new HttpCombinedParser(handler);
var bArray = Encoding.UTF8.GetBytes(TestReponse());
System.Console.WriteLine(parser.Execute(new ArraySegment <byte>(bArray, 0, bArray.Length)) == bArray.Length
? $"Reponse test succeed. Type identified is; {handler.MessageType}"
: $"Response test failed");
bArray = Encoding.UTF8.GetBytes(TestRequest());
System.Console.WriteLine(parser.Execute(new ArraySegment <byte>(bArray, 0, bArray.Length)) == bArray.Length
? $"Request test succeed. Type identified is; {handler.MessageType}"
: $"Request test failed");
System.Console.ReadKey();
}
internal bool Parse(
byte[]?byteArray,
IEnumerable <string>?subProtocols)
{
if (byteArray is null)
{
return(false);
}
_parserHandler.Execute(byteArray);
if (_parserDelegate.HttpRequestResponse is not null &&
_parserDelegate.HttpRequestResponse.IsEndOfMessage)
{
if (_parserDelegate.HttpRequestResponse.StatusCode == 101)
{
if (subProtocols is not null &&
_parserDelegate?.HttpRequestResponse?.Headers is not null)
{
if (_parserDelegate
.HttpRequestResponse
.Headers
.TryGetValue("SEC-WEBSOCKET-PROTOCOL", out var subprotocolAcceptedNames))
{
SubprotocolAcceptedNames = subprotocolAcceptedNames.Where(spn => subProtocols.Contains(spn));
if (!SubprotocolAcceptedNames?.Any() ?? true)
{
_connectionStatusAction(
ConnectionStatus.Aborted,
new WebsocketClientLiteException("Server responded only with subprotocols not known by client."));
}
}
else
{
_connectionStatusAction(
ConnectionStatus.Aborted,
new WebsocketClientLiteException("Server responded with blank Sub Protocol name")
);
}
}
Debug.WriteLine("HandShake completed");
return(true);
}
else
{
_connectionStatusAction(
ConnectionStatus.Aborted,
new WebsocketClientLiteException($"Unable to connect to websocket Server. " +
$"Error code: {_parserDelegate.HttpRequestResponse.StatusCode}, " +
$"Error reason: {_parserDelegate.HttpRequestResponse.ResponseReason}"));
}
}
return(false);
}
internal void Parse(byte[] data, HttpParserDelegate parserDelegate, HttpCombinedParser parserHandler)
{
try
{
if (parserHandler.Execute(new ArraySegment <byte>(data, 0, data.Length)) <= 0)
{
parserDelegate.HttpRequestResponse.IsUnableToParseHttp = true;
}
}
catch (Exception)
{
parserDelegate.HttpRequestResponse.IsUnableToParseHttp = true;
}
}
internal async Task <IHttpRequestResponse> ParseAsync(Stream stream, CancellationToken ct)
{
_disposableParserCompletion = _parserDelegate.ParserCompletionObservable
.Subscribe(parserState =>
{
switch (parserState)
{
case ParserState.Start:
break;
case ParserState.Parsing:
break;
case ParserState.Completed:
break;
case ParserState.Failed:
HasParsingError = true;
break;
default:
throw new ArgumentOutOfRangeException(nameof(parserState), parserState, null);
}
},
ex => throw ex,
() =>
{
IsDone = true;
});
await Observable.While(
() => !HasParsingError && !IsDone,
Observable.FromAsync(() => ReadBytesAsync(stream, ct)))
.Catch <byte[], SimpleHttpListenerException>(ex =>
{
HasParsingError = true;
return(Observable.Return(Enumerable.Empty <byte>().ToArray()));
})
.Where(b => b != Enumerable.Empty <byte>().ToArray())
.Where(bSegment => bSegment.Length > 0)
.Select(b => new ArraySegment <byte>(b, 0, b.Length))
.Select(bSegment => _parser.Execute(bSegment));
_parser.Execute(default);
static void Main(string[] args)
{
byte[] bArray;
using (var handler = new ParserHandler())
using (var parser = new HttpCombinedParser(handler))
{
bArray = TestReponse();
System.Console.WriteLine(parser.Execute(new ArraySegment <byte>(bArray, 0, bArray.Length)) == bArray.Length
? $"Reponse test succeed. Type identified is; {handler.MessageType}"
: $"Response test failed");
handler.HttpRequestReponse.Body.Position = 0;
var reader = new StreamReader(handler.HttpRequestReponse.Body);
var body = reader.ReadToEnd();
//bArray = Encoding.UTF8.GetBytes(TestRequest());
//System.Console.WriteLine(parser.Execute(new ArraySegment<byte>(bArray, 0, bArray.Length)) == bArray.Length
// ? $"Request test succeed. Type identified is; {handler.MessageType}"
// : $"Request test failed");
}
using (var handler = new ParserHandler())
using (var parser = new HttpCombinedParser(handler))
{
bArray = TestChunkedResponse();
System.Console.WriteLine(parser.Execute(new ArraySegment <byte>(bArray, 0, bArray.Length)) == bArray.Length
? $"Chunked Response test succeed. Type identified is; {handler.MessageType}."
: $"Chunked Response test failed");
handler.HttpRequestReponse.Body.Position = 0;
var reader = new StreamReader(handler.HttpRequestReponse.Body);
var body = reader.ReadToEnd();
}
System.Console.ReadKey();
}
