protected void ProcessResponse <O>(IAsyncResult asyncResult)
{
RequestState <O> state = (RequestState <O>)asyncResult.AsyncState;
try {
HttpWebRequest request = state.Request;
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncResult))
{
using (Stream responseStream = response.GetResponseStream())
{
using (StreamReader responseReader = new StreamReader(responseStream, Encoding.UTF8))
{
string jsonString = responseReader.ReadToEnd();
if (string.IsNullOrEmpty(jsonString))
{
throw new TransportException("Empty Response");
}
var data = Marshaller.Unmarshal <O>(jsonString);
state.Response = data;
state.Callback.Success(state.Response);
}
}
}
}
catch (Exception ex)
{
state.Callback.Failure(
new TransportException("Unexpected exception occurred while parsing response.", ex)
);
}
}
public void Send <I, O>(string service, string method, I payload, ClientTransportCallback <O> callback, C ctx)
{
try {
var request = (HttpWebRequest)WebRequest.Create(string.Format("{0}/{1}/{2}", endpoint, service, method));
request.Timeout = Timeout * 1000;
request.Method = payload == null ? "GET" : "POST";
if (HttpHeaders != null)
{
foreach (var key in HttpHeaders.AllKeys)
{
foreach (var value in HttpHeaders.GetValues(key))
{
request.Headers.Add(key, value);
}
}
}
if (payload != null)
{
var data = Marshaller.Marshal <I>(payload);
if (data == null)
{
throw new TransportException("HttpTransport only supports Marshallers which return a string.");
}
request.Method = "POST";
request.ContentType = "application/json";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream()) {
stream.Write(Encoding.UTF8.GetBytes(data), 0, data.Length);
}
}
using (var response = (HttpWebResponse)request.GetResponse()) {
using (var respStream = response.GetResponseStream()) {
using (var reader = new StreamReader(respStream, Encoding.UTF8)) {
string jsonString = reader.ReadToEnd();
if (string.IsNullOrEmpty(jsonString))
{
throw new TransportException("Empty Response");
}
var data = Marshaller.Unmarshal <O>(jsonString);
callback.Success(data);
}
}
}
}
catch (Exception ex)
{
callback.Failure(
new TransportException("Unexpected exception occured during async request.", ex)
);
}
}
protected void ProcessResponse <O>(string text, Dictionary <string, string> headers,
ClientTransportCallback <O> callback)
{
try {
if (string.IsNullOrEmpty(text))
{
throw new TransportException("Empty response.");
}
var data = Marshaller.Unmarshal <O>(text);
callback.Success(data);
} catch (Exception ex) {
callback.Failure(
new TransportException(string.Format("Unexpected exception {0}\n{1}", ex.Message, ex.StackTrace))
);
}
}
private void OnMessage(MessageEventArgs e)
{
_logger.Logf(LogLevel.Trace, "WebSocketTransport: Incoming message:\nType: {0}\nData: {1}", e.IsBinary ? "Binary" : "Text", e.Data);
if (e.IsBinary)
{
throw new Exception("Binary data is not supported.");
}
WebSocketMessageBase messageBase;
try {
messageBase = _marshaller.Unmarshal <WebSocketMessageBase>(e.Data);
}
catch (Exception ex) {
_logger.Logf(LogLevel.Error, "Exception during message unmarshalling: {0}", ex.Message);
return;
}
switch (messageBase.Kind)
{
case WebSocketMessageKind.RpcFailure:
case WebSocketMessageKind.RpcResponse: {
WebSocketResponseMessageJson msg;
try {
msg = _marshaller.Unmarshal <WebSocketResponseMessageJson>(e.Data);
}
catch (Exception ex) {
_logger.Logf(LogLevel.Error, "Exception during RPC message unmarshalling: {0}", ex.Message);
return;
}
HandleRPCSuccess(msg);
} break;
case WebSocketMessageKind.BuzzerRequest: {
WebSocketRequestMessageJson msg;
try {
msg = _marshaller.Unmarshal <WebSocketRequestMessageJson>(e.Data);
}
catch (Exception ex) {
_logger.Logf(LogLevel.Error, "Exception during RPC message unmarshalling: {0}", ex.Message);
return;
}
HandleBuzzer(msg);
} break;
case WebSocketMessageKind.Failure: {
WebSocketFailureMessage msg;
try {
msg = _marshaller.Unmarshal <WebSocketFailureMessage>(e.Data);
} catch (Exception ex) {
_logger.Logf(LogLevel.Error, "Exception during failure message unmarshalling: {0}", ex.Message);
return;
}
HandleFailure(msg);
} break;
default:
throw new Exception("Not implemented");
}
}
protected override void OnMessage(MessageEventArgs e)
{
if (e.IsPing)
{
_logger.Logf(LogLevel.Trace, "WebSocketServer: Ping received.");
return;
}
if (e.IsBinary)
{
_logger.Logf(LogLevel.Error, "WebSocketServer: Binary format messages are not supported.");
return;
}
_logger.Logf(LogLevel.Trace, "WebSocketServer: Incoming message: {0}", e.Data);
WebSocketMessageBase messageBase;
try {
messageBase = _marshaller.Unmarshal <WebSocketMessageBase>(e.Data);
} catch (Exception ex)
{
_logger.Logf(LogLevel.Error, "Failure during processing of base message. {0}", ex.Message);
sendFailure(ex.Message, e.Data);
return;
}
switch (messageBase.Kind)
{
case WebSocketMessageKind.RpcRequest:
{
var res = new WebSocketResponseMessageJson(WebSocketMessageKind.RpcResponse);
WebSocketRequestMessageJson req;
try {
req = _marshaller.Unmarshal <WebSocketRequestMessageJson>(e.Data);
} catch (Exception ex)
{
_logger.Logf(LogLevel.Error, "Failure during processing of RPC request message. {0}", ex.Message);
sendFailure(ex.Message, e.Data);
return;
}
res.Ref = req.ID;
if (req.Headers != null && req.Headers.ContainsKey("Authorization"))
{
_context.System.UpdateAuth(req.Headers["Authorization"]);
if (_handlers != null)
{
if (!_handlers.OnAuthorize(_context))
{
Context.WebSocket.Close();
return;
}
}
if (string.IsNullOrEmpty(req.Service))
{
Send(_marshaller.Marshal(res));
return;
}
}
try {
var data = _dispatcher.Dispatch(_context, req.Service, req.Method, req.Data);
res.Data = data;
}
catch (Exception ex)
{
res.Kind = WebSocketMessageKind.RpcFailure;
res.Data = ex.Message;
}
Send(_marshaller.Marshal(res));
} break;
default: {
sendFailure("Unsupported request.", e.Data);
} break;
}
}