From 07cc0173201a7302439dddc77d4e0b0dbb7d3fac Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Thu, 30 Nov 2017 15:13:56 -0800 Subject: [PATCH] make Task private --- src/application.rs | 12 ++++----- src/dev.rs | 1 - src/httpcodes.rs | 6 ++--- src/pipeline.rs | 16 ++++++------ src/resource.rs | 7 +++--- src/route.rs | 39 +++++++++++++--------------- src/task.rs | 63 +++++++++++++++++++--------------------------- 7 files changed, 61 insertions(+), 83 deletions(-) diff --git a/src/application.rs b/src/application.rs index db9be1bf8..1530e551c 100644 --- a/src/application.rs +++ b/src/application.rs @@ -1,7 +1,6 @@ use std::rc::Rc; use std::collections::HashMap; -use task::Task; use route::{RouteHandler, WrapHandler, Reply, Handler}; use resource::Resource; use recognizer::{RouteRecognizer, check_pattern}; @@ -23,23 +22,22 @@ pub struct Application { impl Application { - fn run(&self, req: HttpRequest, task: &mut Task) { + fn run(&self, req: HttpRequest) -> Reply { let mut req = req.with_state(Rc::clone(&self.state)); if let Some((params, h)) = self.router.recognize(req.path()) { if let Some(params) = params { req.set_match_info(params); } - h.handle(req, task) + h.handle(req) } else { for (prefix, handler) in &self.handlers { if req.path().starts_with(prefix) { req.set_prefix(prefix.len()); - handler.handle(req, task); - return + return handler.handle(req) } } - self.default.handle(req, task) + self.default.handle(req) } } } @@ -49,7 +47,7 @@ impl HttpHandler for Application { fn handle(&self, req: HttpRequest) -> Result { if req.path().starts_with(&self.prefix) { Ok(Pipeline::new(req, Rc::clone(&self.middlewares), - &|req: HttpRequest, task: &mut Task| {self.run(req, task)})) + &|req: HttpRequest| self.run(req))) } else { Err(req) } diff --git a/src/dev.rs b/src/dev.rs index 589ecb13c..cb409ccc0 100644 --- a/src/dev.rs +++ b/src/dev.rs @@ -9,7 +9,6 @@ //! ``` // dev specific -pub use task::Task; pub use pipeline::Pipeline; pub use route::Handler; pub use recognizer::RouteRecognizer; diff --git a/src/httpcodes.rs b/src/httpcodes.rs index 23547019a..44415f5f3 100644 --- a/src/httpcodes.rs +++ b/src/httpcodes.rs @@ -3,7 +3,7 @@ use http::StatusCode; use body::Body; -use task::Task; +use route::Reply; use route::RouteHandler; use httprequest::HttpRequest; use httpresponse::{HttpResponse, HttpResponseBuilder}; @@ -69,8 +69,8 @@ impl StaticResponse { } impl RouteHandler for StaticResponse { - fn handle(&self, _: HttpRequest, task: &mut Task) { - task.reply(HttpResponse::new(self.0, Body::Empty)) + fn handle(&self, _: HttpRequest) -> Reply { + Reply::response(HttpResponse::new(self.0, Body::Empty)) } } diff --git a/src/pipeline.rs b/src/pipeline.rs index 3b6eb7d4c..d286c956b 100644 --- a/src/pipeline.rs +++ b/src/pipeline.rs @@ -4,14 +4,15 @@ use std::rc::Rc; use futures::{Async, Poll, Future}; use task::Task; +use route::Reply; use error::Error; -use middlewares::{Middleware, Finished, Started, Response}; use h1writer::Writer; use httprequest::HttpRequest; use httpresponse::HttpResponse; +use middlewares::{Middleware, Finished, Started, Response}; -type Handler = Fn(HttpRequest, &mut Task); -pub(crate) type PipelineHandler<'a> = &'a Fn(HttpRequest, &mut Task); +type Handler = Fn(HttpRequest) -> Reply; +pub(crate) type PipelineHandler<'a> = &'a Fn(HttpRequest) -> Reply; pub struct Pipeline(PipelineState); @@ -29,8 +30,7 @@ impl Pipeline { pub fn new(req: HttpRequest, mw: Rc>>, handler: PipelineHandler) -> Pipeline { if mw.is_empty() { - let mut task = Task::default(); - (handler)(req.clone(), &mut task); + let task = Task::new((handler)(req.clone())); Pipeline(PipelineState::Task(Box::new((task, req)))) } else { match Start::init(mw, req, handler) { @@ -195,8 +195,7 @@ impl Start { let len = self.middlewares.len(); loop { if self.idx == len { - let mut task = Task::default(); - (unsafe{&*self.hnd})(self.req.clone(), &mut task); + let task = Task::new((unsafe{&*self.hnd})(self.req.clone())); return Ok(StartResult::Ready( Box::new(Handle::new(self.idx-1, self.req.clone(), self.prepare(task), self.middlewares)))) @@ -247,8 +246,7 @@ impl Start { Rc::clone(&self.middlewares))))) } if self.idx == len { - let mut task = Task::default(); - (unsafe{&*self.hnd})(self.req.clone(), &mut task); + let task = Task::new((unsafe{&*self.hnd})(self.req.clone())); return Ok(Async::Ready(Box::new(Handle::new( self.idx-1, self.req.clone(), self.prepare(task), Rc::clone(&self.middlewares))))) diff --git a/src/resource.rs b/src/resource.rs index c9dcdef7d..a21b5e34f 100644 --- a/src/resource.rs +++ b/src/resource.rs @@ -4,7 +4,6 @@ use std::collections::HashMap; use http::Method; use futures::Future; -use task::Task; use error::Error; use route::{Reply, RouteHandler, WrapHandler, Handler, StreamHandler}; use httprequest::HttpRequest; @@ -112,11 +111,11 @@ impl Resource where S: 'static { impl RouteHandler for Resource { - fn handle(&self, req: HttpRequest, task: &mut Task) { + fn handle(&self, req: HttpRequest) -> Reply { if let Some(handler) = self.routes.get(req.method()) { - handler.handle(req, task) + handler.handle(req) } else { - self.default.handle(req, task) + self.default.handle(req) } } } diff --git a/src/route.rs b/src/route.rs index bd89f8b1d..8e6249838 100644 --- a/src/route.rs +++ b/src/route.rs @@ -5,10 +5,10 @@ use actix::Actor; use futures::Future; use error::Error; +use task::IoContext; use context::HttpContext; use httprequest::HttpRequest; use httpresponse::HttpResponse; -use task::{Task, IoContext}; /// Trait defines object that could be regestered as route handler #[allow(unused_variables)] @@ -36,7 +36,7 @@ impl Handler for F /// Represents response process. pub struct Reply(ReplyItem); -enum ReplyItem { +pub(crate) enum ReplyItem { Message(HttpResponse), Actor(Box), Future(Box>), @@ -59,23 +59,12 @@ impl Reply { } /// Send response - pub fn reply>(response: R) -> Reply { + pub fn response>(response: R) -> Reply { Reply(ReplyItem::Message(response.into())) } - pub fn into(self, task: &mut Task) - { - match self.0 { - ReplyItem::Message(msg) => { - task.reply(msg) - }, - ReplyItem::Actor(ctx) => { - task.context(ctx) - } - ReplyItem::Future(fut) => { - task.async(fut) - } - } + pub(crate) fn into(self) -> ReplyItem { + self.0 } } @@ -102,10 +91,16 @@ impl>, S: 'static> From> fo } } +impl From>> for Reply +{ + fn from(item: Box>) -> Self { + Reply(ReplyItem::Future(item)) + } +} + /// Trait defines object that could be regestered as resource route pub(crate) trait RouteHandler: 'static { - /// Handle request - fn handle(&self, req: HttpRequest, task: &mut Task); + fn handle(&self, req: HttpRequest) -> Reply; } /// Route handler wrapper for Handler @@ -134,8 +129,8 @@ impl RouteHandler for WrapHandler R: Into + 'static, S: 'static, { - fn handle(&self, req: HttpRequest, task: &mut Task) { - self.h.handle(req).into().into(task) + fn handle(&self, req: HttpRequest) -> Reply { + self.h.handle(req).into() } } @@ -165,7 +160,7 @@ impl RouteHandler for StreamHandler R: Future + 'static, S: 'static, { - fn handle(&self, req: HttpRequest, task: &mut Task) { - task.async((self.f)(req)) + fn handle(&self, req: HttpRequest) -> Reply { + Reply::async((self.f)(req)) } } diff --git a/src/task.rs b/src/task.rs index 7c5d8883a..ee64106a8 100644 --- a/src/task.rs +++ b/src/task.rs @@ -5,6 +5,7 @@ use std::cell::RefCell; use futures::{Async, Future, Poll}; use futures::task::{Task as FutureTask, current as current_task}; +use route::{Reply, ReplyItem}; use body::{Body, BodyStream, Binary}; use context::Frame; use h1writer::{Writer, WriterState}; @@ -143,7 +144,7 @@ impl Future for DrainFut { } } -pub struct Task { +pub(crate) struct Task { running: TaskRunningState, response: ResponseState, iostate: IOState, @@ -152,21 +153,32 @@ pub struct Task { middlewares: Option, } -#[doc(hidden)] -impl Default for Task { - - fn default() -> Task { - Task { running: TaskRunningState::Running, - response: ResponseState::Reading, - iostate: IOState::Response, - drain: Vec::new(), - stream: TaskStream::None, - middlewares: None } - } -} - impl Task { + pub(crate) fn new(reply: Reply) -> Task { + match reply.into() { + ReplyItem::Message(msg) => { + Task::from_response(msg) + }, + ReplyItem::Actor(ctx) => { + Task { running: TaskRunningState::Running, + response: ResponseState::Reading, + iostate: IOState::Response, + drain: Vec::new(), + stream: TaskStream::Context(ctx), + middlewares: None } + } + ReplyItem::Future(fut) => { + Task { running: TaskRunningState::Running, + response: ResponseState::Reading, + iostate: IOState::Response, + drain: Vec::new(), + stream: TaskStream::Response(fut), + middlewares: None } + } + } + } + pub(crate) fn from_response>(response: R) -> Task { Task { running: TaskRunningState::Running, response: ResponseState::Ready(response.into()), @@ -180,29 +192,6 @@ impl Task { Task::from_response(err.into()) } - pub fn reply>(&mut self, response: R) { - let state = &mut self.response; - match *state { - ResponseState::Reading => - *state = ResponseState::Ready(response.into()), - _ => panic!("Internal task state is broken"), - } - } - - pub fn error>(&mut self, err: E) { - self.reply(err.into()) - } - - pub(crate) fn context(&mut self, ctx: Box) { - self.stream = TaskStream::Context(ctx); - } - - pub fn async(&mut self, fut: F) - where F: Future + 'static - { - self.stream = TaskStream::Response(Box::new(fut)); - } - pub(crate) fn response(&mut self) -> HttpResponse { match self.response { ResponseState::Prepared(ref mut state) => state.take().unwrap(),