/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendResponse; if (msg == null) { context.SendDownstream(message); return; } var result = JsonConvert.SerializeObject(msg.Response, Formatting.None); // send header var header = new byte[5]; header[0] = 1; var lengthBuffer = BitConverter.GetBytes(result.Length); Buffer.BlockCopy(lengthBuffer, 0, header, 1, lengthBuffer.Length); context.SendDownstream(new SendBuffer(header, 0, 5)); // send JSON var slice = _bufferPool.PopSlice(); Encoding.UTF8.GetBytes(result, 0, result.Length, slice.Buffer, slice.StartOffset); slice.Position = slice.StartOffset; slice.Count = result.Length; context.SendDownstream(new SendSlice(slice)); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) return; if (!Thread.CurrentPrincipal.Identity.IsAuthenticated) { var authResponse = msg.HttpRequest.CreateResponse(HttpStatusCode.Unauthorized, "Authorize"); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, authResponse)); return; } var request = msg.HttpRequest; var response = request.CreateResponse(HttpStatusCode.OK, "OK"); if (request.Uri.AbsolutePath.Contains("submit.php") && request.Method == "POST") { Console.WriteLine(request.Form["arne"]); } var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.WriteLine("Welcome " + Thread.CurrentPrincipal.Identity.Name); writer.WriteLine("the time is: " + DateTime.Now); writer.Flush(); stream.Position = 0; response.Body = stream; context.SendDownstream(new SendHttpResponse(request, response)); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendResponse; if (msg == null) { context.SendDownstream(message); return; } var buffer = _bufferPool.PopSlice(); var stream = new BufferPoolStream(_bufferPool, buffer); _encoder.Encode(msg.Response, stream); stream.Position = 0; // send header var header = new byte[6]; header[0] = 1; header[1] = _mapper.GetContentId(msg.Response); var lengthBuffer = BitConverter.GetBytes(buffer.Count); Buffer.BlockCopy(lengthBuffer, 0, header, 2, lengthBuffer.Length); context.SendDownstream(new SendBuffer(header, 0, 6)); // send body context.SendDownstream(new SendStream(stream)); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { return; } if (!Thread.CurrentPrincipal.Identity.IsAuthenticated) { var authResponse = msg.HttpRequest.CreateResponse(HttpStatusCode.Unauthorized, "Authenticate"); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, authResponse)); return; } var request = msg.HttpRequest; var response = request.CreateResponse(HttpStatusCode.OK, "OK"); if (request.Uri.AbsolutePath.Contains("submit.php") && request.Method == "POST") { Console.WriteLine(request.Form["arne"]); } var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.WriteLine("Welcome " + Thread.CurrentPrincipal.Identity.Name); writer.WriteLine("the time is: " + DateTime.Now); writer.Flush(); stream.Position = 0; response.Body = stream; context.SendDownstream(new SendHttpResponse(request, response)); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendResponse; if (msg == null) { context.SendDownstream(message); return; } var buffer = _bufferPool.PopSlice(); var stream = new BufferPoolStream(_bufferPool, buffer); _encoder.Encode(msg.Response, stream); stream.Position = 0; // send header var header = new byte[6]; header[0] = 1; header[1] = _mapper.GetContentId(msg.Response); var lengthBuffer = BitConverter.GetBytes(buffer.Count); Buffer.BlockCopy(lengthBuffer, 0, header, 2, lengthBuffer.Length); context.SendDownstream(new SendBuffer(header, 0, 6)); // send body context.SendDownstream(new SendStream(stream)); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } var slice = _pool.Pop(); var serializer = new HttpHeaderSerializer(); var stream = new SliceStream(slice); serializer.SerializeResponse(msg.Response, stream); context.SendDownstream(new SendSlice(slice, (int)stream.Length)); if (msg.Response.Body != null) { context.SendDownstream(new SendStream(msg.Response.Body)); } if (!msg.Response.KeepAlive) { context.SendDownstream(new Close()); } }
public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } var stream = SerializeHeaders(msg.Response); context.SendDownstream(new SendStream(stream)); context.SendDownstream(new SendStream(msg.Response.Body)); }
private void SendCommand(IPipelineHandlerContext context, SendCommandMessage msg) { if (msg.Command is AuthCmd || msg.Command is SubscribeOnEvents) { context.SendDownstream(msg); _current = msg.Command; return; } _current = new BgApiCmd(msg.Command); var message = new SendCommandMessage(_current); context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var str = Encoding.UTF8.GetString(msg.BufferSlice.Buffer, msg.BufferSlice.Position, msg.BufferSlice.RemainingLength); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } var msg2 = message as SendStream; if (msg2 != null) { var buffer = new byte[msg2.Stream.Length]; msg2.Stream.Read(buffer, 0, buffer.Length); msg2.Stream.Position = 0; var str = Encoding.UTF8.GetString(buffer, 0, buffer.Length); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } context.SendDownstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } var authHeader = msg.HttpRequest.Headers["Authorization"]; if (authHeader == null) { context.SendUpstream(message); return; } var user = _authenticator.Authenticate(msg.HttpRequest); if (user == null) { var response = msg.HttpRequest.CreateResponse(HttpStatusCode.Unauthorized, "Invalid username or password."); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); } else { var principal = _principalFactory.Create(new PrincipalFactoryContext { Request = msg.HttpRequest, User = user }); Thread.CurrentPrincipal = principal; } }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } var authHeader = msg.HttpRequest.Headers["Authorization"]; if (authHeader == null) { context.SendUpstream(message); return; } var user = _authenticator.Authenticate(msg.HttpRequest); if (user == null) { var response = msg.HttpRequest.CreateResponse(HttpStatusCode.Unauthorized, "Invalid username or password."); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); } else { var principal = _principalFactory.Create(new PrincipalFactoryContext {Request = msg.HttpRequest, User = user}); Thread.CurrentPrincipal = principal; } }
public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedMessage; if (msg != null && msg.Message.Headers["Content-Type"] == "auth/request") { var api = new AuthCmd(Password); context.SendDownstream(new SendCommandMessage(api)); return; } var reply = message as CommandReply; if (reply != null && reply.OriginalCommand is AuthCmd) { if (!reply.IsSuccessful) { context.SendUpstream(new AuthenticationFailed(reply.Body)); } else { context.SendUpstream(new Authenticated()); } return; } context.SendUpstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var stream = new MemoryStream(); stream.Write(msg.Slice.Buffer, msg.Slice.Offset, msg.Length); var reader = new StreamReader(stream); var str = reader.ReadToEnd(); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } var msg2 = message as SendStream; if (msg2 != null) { var buffer = new byte[msg2.Stream.Length]; msg2.Stream.Read(buffer, 0, buffer.Length); msg2.Stream.Position = 0; var str = Encoding.UTF8.GetString(buffer, 0, buffer.Length); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } if (msg.Response.StatusCode == (int) HttpStatusCode.Unauthorized) { _authenticator.CreateChallenge(msg.Request, msg.Response); } context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var str = Encoding.UTF8.GetString(msg.BufferSlice.Buffer, msg.BufferSlice.Position, msg.BufferSlice.RemainingLength); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } var msg2 = message as SendStream; if (msg2 != null) { var buffer = new byte[msg2.Stream.Length]; msg2.Stream.Read(buffer, 0, buffer.Length); msg2.Stream.Position = 0; var str = Encoding.UTF8.GetString(buffer, 0, buffer.Length); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var stream = new MemoryStream(); stream.Write(msg.Slice.Buffer, msg.Slice.Offset, msg.Length); var reader = new StreamReader(stream); var str = reader.ReadToEnd(); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } var msg2 = message as SendStream; if (msg2 != null) { var buffer = new byte[msg2.Stream.Length]; msg2.Stream.Read(buffer, 0, buffer.Length); msg2.Stream.Position = 0; var str = Encoding.UTF8.GetString(buffer, 0, buffer.Length); var sb = GetAlphaNumeric(str); _logger.Trace(sb.ToString()); } context.SendDownstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedRequest; if (msg == null) return; var parray = msg.Request.Parameters as object[]; if (parray == null) return; // muhahaha, violating the API specification object result; switch (msg.Request.Method) { case "add": result = int.Parse(parray[0].ToString()) + int.Parse(parray[0].ToString()); break; case "substract": result = int.Parse(parray[0].ToString()) + int.Parse(parray[0].ToString()); break; default: result = "Nothing useful."; break; } var response = new Response(msg.Request.Id, result); context.SendDownstream(new SendResponse(response)); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } var stream = SerializeHeaders(msg.Response); stream.Position = 0; context.SendDownstream(new SendStream(stream)); if (msg.Response.Body != null) context.SendDownstream(new SendStream(msg.Response.Body)); if (!msg.Response.KeepAlive) context.SendDownstream(new Close()); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } if (msg.Response.StatusCode == (int)HttpStatusCode.Unauthorized) { _authenticator.CreateChallenge(msg.Request, msg.Response); } context.SendDownstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } var authHeader = msg.HttpRequest.Headers["Authorization"]; if (authHeader == null) { context.SendUpstream(message); return; } IAuthenticationUser user; try { user = this._authenticator.Authenticate(msg.HttpRequest); } catch (HttpException err) { var response = msg.HttpRequest.CreateResponse(err.StatusCode, err.Message); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); return; } if (user == null) { var response = msg.HttpRequest.CreateResponse(HttpStatusCode.Unauthorized, "Invalid username or password."); context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); } else { var principal = this._principalFactory.Create(new PrincipalFactoryContext(msg.HttpRequest, user)); //Thread.CurrentPrincipal = principal; context.SendUpstream(message); } }
/// <summary> /// Takes a <see cref="Message"/> and converts it into a byte buffer. /// </summary> /// <param name="ctx"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext ctx, IPipelineMessage message) { if (message is SendCommandMessage) { var evt = (SendCommandMessage) message; var slice = EncodeCommand(evt.Command); message = new SendSlice(slice); } ctx.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } var slice = _pool.Pop(); var serializer = new HttpHeaderSerializer(); var stream = new SliceStream(slice); serializer.SerializeResponse(msg.Response, stream); context.SendDownstream(new SendSlice(slice, (int) stream.Length)); if (msg.Response.Body != null) context.SendDownstream(new SendStream(msg.Response.Body)); if (!msg.Response.KeepAlive) context.SendDownstream(new Close()); }
/// <summary> /// Takes a <see cref="Message"/> and converts it into a byte buffer. /// </summary> /// <param name="ctx"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext ctx, IPipelineMessage message) { if (message is SendCommandMessage) { var evt = (SendCommandMessage)message; var slice = EncodeCommand(evt.Command); message = new SendSlice(slice); } ctx.SendDownstream(message); }
/// <summary> /// Send the response back to the remote client /// </summary> public void Send() { if (_httpResponse.Body != null) { _httpResponse.Body.Position = 0; } _httpContext.SendDownstream(new SendHttpResponse(_httpRequest, _httpResponse)); if (_httpResponse.Body != null) { _httpResponse.Body.Dispose(); } }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var failure = message as PipelineFailure; if (failure != null) { var response = new HttpResponse("HTTP/1.1", HttpStatusCode.InternalServerError, "Server failed!"); response.Body = new MemoryStream(); var buffer = Encoding.ASCII.GetBytes(failure.Exception.ToString()); response.Body.Write(buffer, 0, buffer.Length); response.Body.Position = 0; context.SendDownstream(new SendHttpResponse(null, response)); return; } var requestMsg = message as ReceivedHttpRequest; if(requestMsg != null) { var response = new HttpResponse("HTTP/1.1", HttpStatusCode.NotFound, "Failed to find " + requestMsg.HttpRequest.Uri.AbsolutePath); context.SendDownstream(new SendHttpResponse(null, response)); } }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedRequest; if (msg == null) { context.SendUpstream(message); return; } var response = _rpcInvoker.Invoke(msg.Request); context.SendDownstream(new SendResponse(response)); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendHttpResponse; if (msg == null) { context.SendDownstream(message); return; } var stream = SerializeHeaders(msg.Response); stream.Position = 0; context.SendDownstream(new SendStream(stream)); if (msg.Response.Body != null) { context.SendDownstream(new SendStream(msg.Response.Body)); } if (!msg.Response.KeepAlive) { context.SendDownstream(new Close()); } }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendResponse; if (msg == null) { context.SendDownstream(message); return; } var result = JsonConvert.SerializeObject(msg.Response, Formatting.None); // send header var header = new byte[5]; header[0] = 1; var lengthBuffer = BitConverter.GetBytes(result.Length); Buffer.BlockCopy(lengthBuffer, 0, header, 1, lengthBuffer.Length); context.SendDownstream(new SendBuffer(header, 0, 5)); // send JSON var slice = _bufferPool.Pop(); Encoding.UTF8.GetBytes(result, 0, result.Length, slice.Buffer, slice.Offset); context.SendDownstream(new SendSlice(slice, result.Length)); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } var ifModifiedSince = DateTime.MinValue; var header = msg.HttpRequest.Headers["If-Modified-Since"]; if (header != null) { ifModifiedSince = DateTime.Parse(header.Value).ToUniversalTime(); // Allow for file systems with subsecond time stamps ifModifiedSince = new DateTime(ifModifiedSince.Year, ifModifiedSince.Month, ifModifiedSince.Day, ifModifiedSince.Hour, ifModifiedSince.Minute, ifModifiedSince.Second, ifModifiedSince.Kind); } var fileContext = new FileContext(msg.HttpRequest, ifModifiedSince); _fileService.GetFile(fileContext); if (fileContext.LastModifiedAtUtc > DateTime.MinValue) { var response = msg.HttpRequest.CreateResponse(HttpStatusCode.OK, "File found"); var filename = msg.HttpRequest.Uri.Segments[msg.HttpRequest.Uri.Segments.Length - 1]; response.ContentType = _mimeTypeProvider.Get(filename); if (fileContext.FileStream == null) { response.StatusDescription = "File have not changed since " + fileContext.LastModifiedAtUtc; response.StatusCode = (int)HttpStatusCode.NotModified; } else { response.AddHeader("Last-Modified", fileContext.LastModifiedAtUtc.ToString("R")); response.Body = fileContext.FileStream; } context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); return; } context.SendUpstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedRequest; if (msg == null) { context.SendUpstream(message); return; } var response = _rpcInvoker.Invoke(msg.Request); context.SendDownstream(new SendResponse(response)); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var httpmsg = message as ReceivedHttpRequest; if (httpmsg != null) { if (httpmsg.HttpRequest.ContentLength > _sizeLimit) { var response = httpmsg.HttpRequest.CreateResponse(HttpStatusCode.RequestEntityTooLarge, string.Format("Max body size is {0} bytes.", _sizeLimit)); context.SendDownstream(new SendHttpResponse(httpmsg.HttpRequest, response)); return; } if (httpmsg.HttpRequest.ContentLength == 0) { context.SendUpstream(message); return; } _currentMessage = httpmsg.HttpRequest; return; // don't send the request upwards. } var msg = message as Received; if (msg != null) { if (_currentMessage == null) { throw new InvalidOperationException("Current message is not set. We have no way of knowing when to stop decoding the body."); } var result = ParseBody(msg.BufferReader); if (!result) { return; } _currentMessage.Body.Position = 0; _decoderService.Decode((IRequest)_currentMessage); context.SendUpstream(new ReceivedHttpRequest((HttpRequest)_currentMessage)); _currentMessage = null; return; } // pass on all other messages context.SendUpstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var failure = message as PipelineFailure; if (failure != null) { var response = new HttpResponse("HTTP/1.1", HttpStatusCode.InternalServerError, "Server failed!"); response.Body = new MemoryStream(); var buffer = Encoding.ASCII.GetBytes(failure.Exception.ToString()); response.Body.Write(buffer, 0, buffer.Length); response.Body.Position = 0; context.SendDownstream(new SendHttpResponse(null, response)); return; } var requestMsg = message as ReceivedHttpRequest; if (requestMsg != null) { var response = new HttpResponse("HTTP/1.1", HttpStatusCode.NotFound, "Failed to find " + requestMsg.HttpRequest.Uri.AbsolutePath); context.SendDownstream(new SendHttpResponse(null, response)); } }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var bytes = Encoding.ASCII.GetBytes("\r\nTo FreeSwitch ***************** " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToString("HH:mm:ss.nnn") + " ******************\r\n\r\n"); _destinationStream.Write(bytes, 0, bytes.Length); _destinationStream.Write(msg.BufferSlice.Buffer, 0, msg.BufferSlice.Count); _destinationStream.Flush(); } context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as SendSlice; if (msg != null) { var bytes = Encoding.ASCII.GetBytes("\r\nTo FreeSwitch ***************** " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToString("HH:mm:ss.nnn") + " ******************\r\n\r\n"); _destinationStream.Write(bytes, 0, bytes.Length); _destinationStream.Write(msg.BufferSlice.Buffer, 0, msg.BufferSlice.Count); _destinationStream.Flush(); } context.SendDownstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var headerMsg = message as ReceivedHeader; if (headerMsg != null) { _header = headerMsg.Header; if (_header.Length > 65535) { var error = new ErrorResponse("-9999", new RpcError { Code = RpcErrorCode.InvalidRequest, Message = "Support requests which is at most 655355 bytes.", }); context.SendDownstream(new SendResponse(error)); } return; } var received = message as Received; if (received != null) { var count = Math.Min(received.BufferSlice.RemainingLength, _header.Length); _stream.Write(received.BufferSlice.Buffer, received.BufferSlice.Position, count); received.BufferSlice.Position += count; if (_stream.Length == _header.Length) { _stream.Position = 0; var request = DeserializeRequest(_stream); context.SendUpstream(new ReceivedRequest(request)); } return; } context.SendUpstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var httpmsg = message as ReceivedHttpRequest; if (httpmsg != null) { if (httpmsg.HttpRequest.ContentLength > _sizeLimit) { var response = httpmsg.HttpRequest.CreateResponse(HttpStatusCode.RequestEntityTooLarge, string.Format("Max body size is {0} bytes.", _sizeLimit)); context.SendDownstream(new SendHttpResponse(httpmsg.HttpRequest, response)); return; } if (httpmsg.HttpRequest.ContentLength == 0) { context.SendUpstream(message); return; } _currentMessage = httpmsg.HttpRequest; return; // don't send the request upwards. } var msg = message as Received; if (msg != null) { var result = ParseBody(msg.BufferReader); if (!result) return; _currentMessage.Body.Position = 0; _decoderService.Decode((IRequest) _currentMessage); context.SendUpstream(new ReceivedHttpRequest((HttpRequest) _currentMessage)); _currentMessage = null; return; } // pass on all other messages context.SendUpstream(message); }
public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedMessage; if (msg != null && msg.Message.Headers["Content-Type"] == "auth/request") { var api = new AuthCmd(Password); context.SendDownstream(new SendCommandMessage(api)); return; } var reply = message as CommandReply; if (reply != null && reply.OriginalCommand is AuthCmd) { if (!reply.IsSuccessful) context.SendUpstream(new AuthenticationFailed(reply.Body)); else context.SendUpstream(new Authenticated()); return; } context.SendUpstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } try { context.SendUpstream(message); } catch (HttpException err) { var response = msg.HttpRequest.CreateResponse(err.StatusCode, err.Message); FormatException(response, msg, err); response.Body.Position = 0; context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); } }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { if (!(message is SendCommandMessage)) { context.SendDownstream(message); return; } lock (_outbound) { var cmd = (SendCommandMessage) message; if (_current == null) { _logger.Trace("Passing command down " + cmd.Command); SendCommand(context, cmd); } else { _logger.Debug("Enqueueing command " + cmd.Command); _outbound.Enqueue(cmd); } } }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { if (!(message is SendCommandMessage)) { context.SendDownstream(message); return; } lock (_outbound) { var cmd = (SendCommandMessage)message; if (_current == null) { _logger.Trace("Passing command down " + cmd.Command); SendCommand(context, cmd); } else { _logger.Debug("Enqueueing command " + cmd.Command); _outbound.Enqueue(cmd); } } }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var headerMsg = message as ReceivedHeader; if (headerMsg != null) { _header = headerMsg.Header; if (_header.Length > 65535) { var error = new ErrorResponse("-9999", new RpcError { Code = RpcErrorCode.InvalidRequest, Message = "Support requests which is at most 655355 bytes.", }); context.SendDownstream(new SendResponse(error)); } return; } var received = message as Received; if (received != null) { var count = Math.Min(received.BufferReader.Count, _header.Length); received.BufferReader.CopyTo(_stream, count); if (_stream.Length == _header.Length) { _stream.Position = 0; var request = DeserializeRequest(_stream); context.SendUpstream(new ReceivedRequest(request)); } return; } context.SendUpstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedRequest; if (msg == null) { return; } var parray = msg.Request.Parameters as object[]; if (parray == null) { return; // muhahaha, violating the API specification } object result; switch (msg.Request.Method) { case "add": result = int.Parse(parray[0].ToString()) + int.Parse(parray[0].ToString()); break; case "substract": result = int.Parse(parray[0].ToString()) + int.Parse(parray[0].ToString()); break; default: result = "Nothing useful."; break; } var response = new Response(msg.Request.Id, result); context.SendDownstream(new SendResponse(response)); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } try { context.SendUpstream(message); } catch (HttpException err) { var response = msg.HttpRequest.CreateResponse(err.StatusCode, err.Message); FormatException(response, msg, err); response.Body.Position = 0; context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); } }
public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { Assert.Equal(_index, CurrentIndex); CurrentIndex--; context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { context.SendDownstream(message); }
private void SendCommand(IPipelineHandlerContext context, SendCommandMessage msg) { if (msg.Command is AuthCmd || msg.Command is SubscribeOnEvents) { context.SendDownstream(msg); _current = msg.Command; return; } _current = new BgApiCmd(msg.Command); var message = new SendCommandMessage(_current); context.SendDownstream(message); }
/// <summary> /// Process message /// </summary> /// <param name="context"></param> /// <param name="message"></param> /// <remarks> /// Should always call either <see cref="IPipelineHandlerContext.SendDownstream"/> or <see cref="IPipelineHandlerContext.SendUpstream"/> /// unless the handler really wants to stop the processing. /// </remarks> public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { context.SendDownstream(message); }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { var msg = message as ReceivedHttpRequest; if (msg == null) { context.SendUpstream(message); return; } var ifModifiedSince = DateTime.MinValue; var header = msg.HttpRequest.Headers["If-Modified-Since"]; if (header != null) { ifModifiedSince = DateTime.Parse(header.Value).ToUniversalTime(); // Allow for file systems with subsecond time stamps ifModifiedSince = new DateTime(ifModifiedSince.Year, ifModifiedSince.Month, ifModifiedSince.Day, ifModifiedSince.Hour, ifModifiedSince.Minute, ifModifiedSince.Second, ifModifiedSince.Kind); } var fileContext = new FileContext(msg.HttpRequest, ifModifiedSince); _fileService.GetFile(fileContext); if (fileContext.LastModifiedAtUtc > DateTime.MinValue) { var response = msg.HttpRequest.CreateResponse(HttpStatusCode.OK, "File found"); var filename = msg.HttpRequest.Uri.Segments[msg.HttpRequest.Uri.Segments.Length - 1]; response.ContentType = _mimeTypeProvider.Get(filename); if (fileContext.FileStream == null) { response.StatusDescription = "File have not changed since " + fileContext.LastModifiedAtUtc; response.StatusCode = (int) HttpStatusCode.NotModified; } else { response.AddHeader("Last-Modified", fileContext.LastModifiedAtUtc.ToString("R")); response.Body = fileContext.FileStream; } context.SendDownstream(new SendHttpResponse(msg.HttpRequest, response)); return; } context.SendUpstream(message); }
public void HandleDownstream(IPipelineHandlerContext context, IPipelineMessage message) { Assert.Equal(_index, CurrentIndex); CurrentIndex--; context.SendDownstream(message); }
private void OnReConnect(object state) { _upstreamContext.SendDownstream(new Connect(_endPoint)); _timer.Change(Timeout.Infinite, Timeout.Infinite); }