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; } }