= + BoxedNewService<(), ServiceRequest
, ServiceResponse, Error, ()>;
+
+/// Return the MIME type associated with a filename extension (case-insensitive).
+/// If `ext` is empty or no associated type for the extension was found, returns
+/// the type `application/octet-stream`.
+#[inline]
+pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
+ get_mime_type(ext)
+}
+
+#[doc(hidden)]
+/// A helper created from a `std::fs::File` which reads the file
+/// chunk-by-chunk on a `ThreadPool`.
+pub struct ChunkedReadFile {
+ size: u64,
+ offset: u64,
+ file: Option for Files ) {
+ if self.default.borrow().is_none() {
+ *self.default.borrow_mut() = Some(config.default_service());
+ }
+ let rdef = if config.is_root() {
+ ResourceDef::root_prefix(&self.path)
+ } else {
+ ResourceDef::prefix(&self.path)
+ };
+ config.register_service(rdef, None, self, None)
+ }
+}
+
+impl ;
+ type Response = ServiceResponse;
+ type Error = Error;
+ type Service = FilesService ;
+ type Response = ServiceResponse;
+ type Error = Error;
+ type Future = FutureResult ) -> Self::Future {
+ let (req, _) = req.into_parts();
+
+ let real_path = match PathBufWrp::get_pathbuf(req.match_info().path()) {
+ Ok(item) => item,
+ Err(e) => return ok(ServiceResponse::from_err(e, req.clone())),
+ };
+
+ // full filepath
+ let path = match self.directory.join(&real_path.0).canonicalize() {
+ Ok(path) => path,
+ Err(e) => return ok(ServiceResponse::from_err(e, req.clone())),
+ };
+
+ if path.is_dir() {
+ if let Some(ref redir_index) = self.index {
+ let path = path.join(redir_index);
+
+ match NamedFile::open_with_config(path, C::default()) {
+ Ok(named_file) => match named_file.respond_to(&req) {
+ Ok(item) => ok(ServiceResponse::new(req.clone(), item)),
+ Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+ },
+ Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+ }
+ } else if self.show_index {
+ let dir = Directory::new(self.directory.clone(), path);
+ let x = (self.renderer)(&dir, &req);
+ match x {
+ Ok(resp) => ok(resp),
+ Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+ }
+ } else {
+ ok(ServiceResponse::from_err(
+ FilesError::IsDirectory,
+ req.clone(),
+ ))
+ }
+ } else {
+ match NamedFile::open_with_config(path, C::default()) {
+ Ok(named_file) => match named_file.respond_to(&req) {
+ Ok(item) => ok(ServiceResponse::new(req.clone(), item)),
+ Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+ },
+ Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+ }
+ }
+ }
+}
+
+#[derive(Debug)]
+struct PathBufWrp(PathBuf);
+
+impl PathBufWrp {
+ fn get_pathbuf(path: &str) -> Result FromRequest for PathBufWrp {
+ type Error = UriSegmentError;
+ type Future = Result ) -> Self::Future {
+ PathBufWrp::get_pathbuf(req.match_info().path())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use std::fs;
+ use std::iter::FromIterator;
+ use std::ops::Add;
+ use std::time::{Duration, SystemTime};
+
+ use bytes::BytesMut;
+
+ use super::*;
+ use actix_web::http::{header, header::DispositionType, Method, StatusCode};
+ use actix_web::test::{self, TestRequest};
+ use actix_web::App;
+
+ #[test]
+ fn test_file_extension_to_mime() {
+ let m = file_extension_to_mime("jpg");
+ assert_eq!(m, mime::IMAGE_JPEG);
+
+ let m = file_extension_to_mime("invalid extension!!");
+ assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
+
+ let m = file_extension_to_mime("");
+ assert_eq!(m, mime::APPLICATION_OCTET_STREAM);
+ }
+
+ #[test]
+ fn test_if_modified_since_without_if_none_match() {
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let since =
+ header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+
+ let req = TestRequest::default()
+ .header(header::IF_MODIFIED_SINCE, since)
+ .to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
+ }
+
+ #[test]
+ fn test_if_modified_since_with_if_none_match() {
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let since =
+ header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+
+ let req = TestRequest::default()
+ .header(header::IF_NONE_MATCH, "miss_etag")
+ .header(header::IF_MODIFIED_SINCE, since)
+ .to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_ne!(resp.status(), StatusCode::NOT_MODIFIED);
+ }
+
+ #[test]
+ fn test_named_file_text() {
+ assert!(NamedFile::open("test--").is_err());
+ let mut file = NamedFile::open("Cargo.toml").unwrap();
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "text/x-toml"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "inline; filename=\"Cargo.toml\""
+ );
+ }
+
+ #[test]
+ fn test_named_file_set_content_type() {
+ let mut file = NamedFile::open("Cargo.toml")
+ .unwrap()
+ .set_content_type(mime::TEXT_XML);
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "text/xml"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "inline; filename=\"Cargo.toml\""
+ );
+ }
+
+ #[test]
+ fn test_named_file_image() {
+ let mut file = NamedFile::open("tests/test.png").unwrap();
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "image/png"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "inline; filename=\"test.png\""
+ );
+ }
+
+ #[test]
+ fn test_named_file_image_attachment() {
+ use header::{ContentDisposition, DispositionParam, DispositionType};
+ let cd = ContentDisposition {
+ disposition: DispositionType::Attachment,
+ parameters: vec![DispositionParam::Filename(String::from("test.png"))],
+ };
+ let mut file = NamedFile::open("tests/test.png")
+ .unwrap()
+ .set_content_disposition(cd);
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "image/png"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "attachment; filename=\"test.png\""
+ );
+ }
+
+ #[derive(Default)]
+ pub struct AllAttachmentConfig;
+ impl StaticFileConfig for AllAttachmentConfig {
+ fn content_disposition_map(_typ: mime::Name) -> DispositionType {
+ DispositionType::Attachment
+ }
+ }
+
+ #[derive(Default)]
+ pub struct AllInlineConfig;
+ impl StaticFileConfig for AllInlineConfig {
+ fn content_disposition_map(_typ: mime::Name) -> DispositionType {
+ DispositionType::Inline
+ }
+ }
+
+ #[test]
+ fn test_named_file_image_attachment_and_custom_config() {
+ let file =
+ NamedFile::open_with_config("tests/test.png", AllAttachmentConfig).unwrap();
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "image/png"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "attachment; filename=\"test.png\""
+ );
+
+ let file =
+ NamedFile::open_with_config("tests/test.png", AllInlineConfig).unwrap();
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "image/png"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "inline; filename=\"test.png\""
+ );
+ }
+
+ #[test]
+ fn test_named_file_binary() {
+ let mut file = NamedFile::open("tests/test.binary").unwrap();
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "application/octet-stream"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "attachment; filename=\"test.binary\""
+ );
+ }
+
+ #[test]
+ fn test_named_file_status_code_text() {
+ let mut file = NamedFile::open("Cargo.toml")
+ .unwrap()
+ .set_status_code(StatusCode::NOT_FOUND);
+ {
+ file.file();
+ let _f: &File = &file;
+ }
+ {
+ let _f: &mut File = &mut file;
+ }
+
+ let req = TestRequest::default().to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "text/x-toml"
+ );
+ assert_eq!(
+ resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ "inline; filename=\"Cargo.toml\""
+ );
+ assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+ }
+
+ #[test]
+ fn test_named_file_ranges_status_code() {
+ let mut srv = test::init_service(
+ App::new().service(Files::new("/test", ".").index_file("Cargo.toml")),
+ );
+
+ // Valid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/Cargo.toml")
+ .header(header::RANGE, "bytes=10-20")
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+ assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
+
+ // Invalid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/Cargo.toml")
+ .header(header::RANGE, "bytes=1-0")
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+
+ assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+ }
+
+ #[test]
+ fn test_named_file_content_range_headers() {
+ let mut srv = test::init_service(
+ App::new().service(Files::new("/test", ".").index_file("tests/test.binary")),
+ );
+
+ // Valid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ .header(header::RANGE, "bytes=10-20")
+ .to_request();
+
+ let response = test::call_success(&mut srv, request);
+ let contentrange = response
+ .headers()
+ .get(header::CONTENT_RANGE)
+ .unwrap()
+ .to_str()
+ .unwrap();
+
+ assert_eq!(contentrange, "bytes 10-20/100");
+
+ // Invalid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ .header(header::RANGE, "bytes=10-5")
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+
+ let contentrange = response
+ .headers()
+ .get(header::CONTENT_RANGE)
+ .unwrap()
+ .to_str()
+ .unwrap();
+
+ assert_eq!(contentrange, "bytes */100");
+ }
+
+ #[test]
+ fn test_named_file_content_length_headers() {
+ let mut srv = test::init_service(
+ App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
+ );
+
+ // Valid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ .header(header::RANGE, "bytes=10-20")
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+
+ let contentlength = response
+ .headers()
+ .get(header::CONTENT_LENGTH)
+ .unwrap()
+ .to_str()
+ .unwrap();
+
+ assert_eq!(contentlength, "11");
+
+ // Invalid range header
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ .header(header::RANGE, "bytes=10-8")
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+ assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+
+ // Without range header
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ // .no_default_headers()
+ .to_request();
+ let response = test::call_success(&mut srv, request);
+
+ let contentlength = response
+ .headers()
+ .get(header::CONTENT_LENGTH)
+ .unwrap()
+ .to_str()
+ .unwrap();
+
+ assert_eq!(contentlength, "100");
+
+ // chunked
+ let request = TestRequest::get()
+ .uri("/t%65st/tests/test.binary")
+ .to_request();
+ let mut response = test::call_success(&mut srv, request);
+
+ // with enabled compression
+ // {
+ // let te = response
+ // .headers()
+ // .get(header::TRANSFER_ENCODING)
+ // .unwrap()
+ // .to_str()
+ // .unwrap();
+ // assert_eq!(te, "chunked");
+ // }
+
+ let bytes =
+ test::block_on(response.take_body().fold(BytesMut::new(), |mut b, c| {
+ b.extend(c);
+ Ok::<_, Error>(b)
+ }))
+ .unwrap();
+ let data = Bytes::from(fs::read("tests/test.binary").unwrap());
+ assert_eq!(bytes.freeze(), data);
+ }
+
+ #[test]
+ fn test_static_files_with_spaces() {
+ let mut srv = test::init_service(
+ App::new().service(Files::new("/", ".").index_file("Cargo.toml")),
+ );
+ let request = TestRequest::get()
+ .uri("/tests/test%20space.binary")
+ .to_request();
+ let mut response = test::call_success(&mut srv, request);
+ assert_eq!(response.status(), StatusCode::OK);
+
+ let bytes =
+ test::block_on(response.take_body().fold(BytesMut::new(), |mut b, c| {
+ b.extend(c);
+ Ok::<_, Error>(b)
+ }))
+ .unwrap();
+
+ let data = Bytes::from(fs::read("tests/test space.binary").unwrap());
+ assert_eq!(bytes.freeze(), data);
+ }
+
+ #[derive(Default)]
+ pub struct OnlyMethodHeadConfig;
+ impl StaticFileConfig for OnlyMethodHeadConfig {
+ fn is_method_allowed(method: &Method) -> bool {
+ match *method {
+ Method::HEAD => true,
+ _ => false,
+ }
+ }
+ }
+
+ #[test]
+ fn test_named_file_not_allowed() {
+ let file =
+ NamedFile::open_with_config("Cargo.toml", OnlyMethodHeadConfig).unwrap();
+ let req = TestRequest::default()
+ .method(Method::POST)
+ .to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+
+ let file =
+ NamedFile::open_with_config("Cargo.toml", OnlyMethodHeadConfig).unwrap();
+ let req = TestRequest::default().method(Method::PUT).to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+
+ let file =
+ NamedFile::open_with_config("Cargo.toml", OnlyMethodHeadConfig).unwrap();
+ let req = TestRequest::default().method(Method::GET).to_http_request();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+ }
+
+ // #[test]
+ // fn test_named_file_content_encoding() {
+ // let req = TestRequest::default().method(Method::GET).finish();
+ // let file = NamedFile::open("Cargo.toml").unwrap();
+
+ // assert!(file.encoding.is_none());
+ // let resp = file
+ // .set_content_encoding(ContentEncoding::Identity)
+ // .respond_to(&req)
+ // .unwrap();
+
+ // assert!(resp.content_encoding().is_some());
+ // assert_eq!(resp.content_encoding().unwrap().as_str(), "identity");
+ // }
+
+ #[test]
+ fn test_named_file_any_method() {
+ let req = TestRequest::default()
+ .method(Method::POST)
+ .to_http_request();
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let resp = file.respond_to(&req).unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ }
+
+ #[test]
+ fn test_static_files() {
+ let mut srv = test::init_service(
+ App::new().service(Files::new("/", ".").show_files_listing()),
+ );
+ let req = TestRequest::with_uri("/missing").to_request();
+
+ let resp = test::call_success(&mut srv, req);
+ assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+
+ let mut srv = test::init_service(App::new().service(Files::new("/", ".")));
+
+ let req = TestRequest::default().to_request();
+ let resp = test::call_success(&mut srv, req);
+ assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+
+ let mut srv = test::init_service(
+ App::new().service(Files::new("/", ".").show_files_listing()),
+ );
+ let req = TestRequest::with_uri("/tests").to_request();
+ let mut resp = test::call_success(&mut srv, req);
+ assert_eq!(
+ resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ "text/html; charset=utf-8"
+ );
+
+ let bytes =
+ test::block_on(resp.take_body().fold(BytesMut::new(), |mut b, c| {
+ b.extend(c);
+ Ok::<_, Error>(b)
+ }))
+ .unwrap();
+ assert!(format!("{:?}", bytes).contains("/tests/test.png"));
+ }
+
+ #[test]
+ fn test_static_files_bad_directory() {
+ let _st: Files<()> = Files::new("/", "missing");
+ let _st: Files<()> = Files::new("/", "Cargo.toml");
+ }
+
+ // #[test]
+ // fn test_default_handler_file_missing() {
+ // let st = Files::new(".")
+ // .default_handler(|_: &_| "default content");
+ // let req = TestRequest::with_uri("/missing")
+ // .param("tail", "missing")
+ // .finish();
+
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::OK);
+ // assert_eq!(
+ // resp.body(),
+ // &Body::Binary(Binary::Slice(b"default content"))
+ // );
+ // }
+
+ // #[test]
+ // fn test_serve_index() {
+ // let st = Files::new(".").index_file("test.binary");
+ // let req = TestRequest::default().uri("/tests").finish();
+
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::OK);
+ // assert_eq!(
+ // resp.headers()
+ // .get(header::CONTENT_TYPE)
+ // .expect("content type"),
+ // "application/octet-stream"
+ // );
+ // assert_eq!(
+ // resp.headers()
+ // .get(header::CONTENT_DISPOSITION)
+ // .expect("content disposition"),
+ // "attachment; filename=\"test.binary\""
+ // );
+
+ // let req = TestRequest::default().uri("/tests/").finish();
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::OK);
+ // assert_eq!(
+ // resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ // "application/octet-stream"
+ // );
+ // assert_eq!(
+ // resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ // "attachment; filename=\"test.binary\""
+ // );
+
+ // // nonexistent index file
+ // let req = TestRequest::default().uri("/tests/unknown").finish();
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+
+ // let req = TestRequest::default().uri("/tests/unknown/").finish();
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+ // }
+
+ // #[test]
+ // fn test_serve_index_nested() {
+ // let st = Files::new(".").index_file("mod.rs");
+ // let req = TestRequest::default().uri("/src/client").finish();
+ // let resp = st.handle(&req).respond_to(&req).unwrap();
+ // let resp = resp.as_msg();
+ // assert_eq!(resp.status(), StatusCode::OK);
+ // assert_eq!(
+ // resp.headers().get(header::CONTENT_TYPE).unwrap(),
+ // "text/x-rust"
+ // );
+ // assert_eq!(
+ // resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+ // "inline; filename=\"mod.rs\""
+ // );
+ // }
+
+ // #[test]
+ // fn integration_serve_index() {
+ // let mut srv = test::TestServer::with_factory(|| {
+ // App::new().handler(
+ // "test",
+ // Files::new(".").index_file("Cargo.toml"),
+ // )
+ // });
+
+ // let request = srv.get().uri(srv.url("/test")).finish().unwrap();
+ // let response = srv.execute(request.send()).unwrap();
+ // assert_eq!(response.status(), StatusCode::OK);
+ // let bytes = srv.execute(response.body()).unwrap();
+ // let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+ // assert_eq!(bytes, data);
+
+ // let request = srv.get().uri(srv.url("/test/")).finish().unwrap();
+ // let response = srv.execute(request.send()).unwrap();
+ // assert_eq!(response.status(), StatusCode::OK);
+ // let bytes = srv.execute(response.body()).unwrap();
+ // let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+ // assert_eq!(bytes, data);
+
+ // // nonexistent index file
+ // let request = srv.get().uri(srv.url("/test/unknown")).finish().unwrap();
+ // let response = srv.execute(request.send()).unwrap();
+ // assert_eq!(response.status(), StatusCode::NOT_FOUND);
+
+ // let request = srv.get().uri(srv.url("/test/unknown/")).finish().unwrap();
+ // let response = srv.execute(request.send()).unwrap();
+ // assert_eq!(response.status(), StatusCode::NOT_FOUND);
+ // }
+
+ // #[test]
+ // fn integration_percent_encoded() {
+ // let mut srv = test::TestServer::with_factory(|| {
+ // App::new().handler(
+ // "test",
+ // Files::new(".").index_file("Cargo.toml"),
+ // )
+ // });
+
+ // let request = srv
+ // .get()
+ // .uri(srv.url("/test/%43argo.toml"))
+ // .finish()
+ // .unwrap();
+ // let response = srv.execute(request.send()).unwrap();
+ // assert_eq!(response.status(), StatusCode::OK);
+ // }
+
+ #[test]
+ fn test_path_buf() {
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/test/.tt").map(|t| t.0),
+ Err(UriSegmentError::BadStart('.'))
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/test/*tt").map(|t| t.0),
+ Err(UriSegmentError::BadStart('*'))
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/test/tt:").map(|t| t.0),
+ Err(UriSegmentError::BadEnd(':'))
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/test/tt<").map(|t| t.0),
+ Err(UriSegmentError::BadEnd('<'))
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/test/tt>").map(|t| t.0),
+ Err(UriSegmentError::BadEnd('>'))
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/seg1/seg2/").unwrap().0,
+ PathBuf::from_iter(vec!["seg1", "seg2"])
+ );
+ assert_eq!(
+ PathBufWrp::get_pathbuf("/seg1/../seg2/").unwrap().0,
+ PathBuf::from_iter(vec!["seg2"])
+ );
+ }
+}
diff --git a/actix-files/src/named.rs b/actix-files/src/named.rs
new file mode 100644
index 00000000..6372a183
--- /dev/null
+++ b/actix-files/src/named.rs
@@ -0,0 +1,439 @@
+use std::fs::{File, Metadata};
+use std::io;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[cfg(unix)]
+use std::os::unix::fs::MetadataExt;
+
+use mime;
+use mime_guess::guess_mime_type;
+
+use actix_http::error::Error;
+use actix_http::http::header::{self, ContentDisposition, DispositionParam};
+use actix_web::http::{ContentEncoding, Method, StatusCode};
+use actix_web::{HttpMessage, HttpRequest, HttpResponse, Responder};
+
+use crate::config::{DefaultConfig, StaticFileConfig};
+use crate::range::HttpRange;
+use crate::ChunkedReadFile;
+
+/// A file with an associated name.
+#[derive(Debug)]
+pub struct NamedFile (&self, req: &ServiceRequest ) -> HashMap ;
+ type Response = ServiceResponse;
+ type Error = S::Error;
+ type InitError = ();
+ type Transform = CookieSessionMiddleware ;
+ type Response = ServiceResponse;
+ type Error = S::Error;
+ type Future = Box ) -> Self::Future {
+ let inner = self.inner.clone();
+ let state = self.inner.load(&req);
+ Session::set_session(state.into_iter(), &mut req);
+
+ Box::new(self.service.call(req).map(move |mut res| {
+ if let Some(state) = Session::get_changes(&mut res) {
+ res.checked_expr(|res| inner.set_cookie(res, state))
+ } else {
+ res
+ }
+ }))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use actix_web::{test, web, App};
+
+ #[test]
+ fn cookie_session() {
+ let mut app = test::init_service(
+ App::new()
+ .middleware(CookieSession::signed(&[0; 32]).secure(false))
+ .service(web::resource("/").to(|ses: Session| {
+ let _ = ses.set("counter", 100);
+ "test"
+ })),
+ );
+
+ let request = test::TestRequest::get().to_request();
+ let response = test::block_on(app.call(request)).unwrap();
+ assert!(response
+ .cookies()
+ .find(|c| c.name() == "actix-session")
+ .is_some());
+ }
+
+ #[test]
+ fn cookie_session_extractor() {
+ let mut app = test::init_service(
+ App::new()
+ .middleware(CookieSession::signed(&[0; 32]).secure(false))
+ .service(web::resource("/").to(|ses: Session| {
+ let _ = ses.set("counter", 100);
+ "test"
+ })),
+ );
+
+ let request = test::TestRequest::get().to_request();
+ let response = test::block_on(app.call(request)).unwrap();
+ assert!(response
+ .cookies()
+ .find(|c| c.name() == "actix-session")
+ .is_some());
+ }
+}
diff --git a/actix-session/src/lib.rs b/actix-session/src/lib.rs
new file mode 100644
index 00000000..1dd367ba
--- /dev/null
+++ b/actix-session/src/lib.rs
@@ -0,0 +1,183 @@
+//! User sessions.
+//!
+//! Actix provides a general solution for session management. Session
+//! middlewares could provide different implementations which could
+//! be accessed via general session api.
+//!
+//! By default, only cookie session backend is implemented. Other
+//! backend implementations can be added.
+//!
+//! In general, you insert a *session* middleware and initialize it
+//! , such as a `CookieSessionBackend`. To access session data,
+//! [*Session*](struct.Session.html) extractor must be used. Session
+//! extractor allows us to get or set session data.
+//!
+//! ```rust
+//! use actix_web::{web, App, HttpServer, HttpResponse, Error};
+//! use actix_session::{Session, CookieSession};
+//!
+//! fn index(session: Session) -> Result<&'static str, Error> {
+//! // access session data
+//! if let Some(count) = session.get:: (
+ data: impl Iterator ,
+ ) {
+ let session = Session::get_session(req);
+ let mut inner = session.0.borrow_mut();
+ inner.state.extend(data);
+ }
+
+ pub fn get_changes(
+ res: &mut ServiceResponse,
+ ) -> Option FromRequest for Session {
+ type Error = Error;
+ type Future = Result ) -> Self::Future {
+ Ok(Session::get_session(req))
+ }
+}
diff --git a/actix-web-actors/Cargo.toml b/actix-web-actors/Cargo.toml
new file mode 100644
index 00000000..db42a1a2
--- /dev/null
+++ b/actix-web-actors/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "actix-web-actors"
+version = "0.1.0"
+authors = ["Nikolay Kim for #name {
+ fn register(self, config: &mut actix_web::dev::ServiceConfig ) {
+ #ast
+ actix_web::dev::HttpServiceFactory::register(
+ actix_web::Resource::new(#path)
+ .guard(actix_web::guard::Get())
+ .to(#name), config);
+ }
+ }
+ })
+ .into()
+}
+
+/// #[post("path")] attribute
+#[proc_macro_attribute]
+pub fn post(args: TokenStream, input: TokenStream) -> TokenStream {
+ let args = parse_macro_input!(args as syn::AttributeArgs);
+ if args.is_empty() {
+ panic!("invalid server definition, expected: #[get(\"some path\")]");
+ }
+
+ // path
+ let path = match args[0] {
+ syn::NestedMeta::Literal(syn::Lit::Str(ref fname)) => {
+ let fname = quote!(#fname).to_string();
+ fname.as_str()[1..fname.len() - 1].to_owned()
+ }
+ _ => panic!("resource path"),
+ };
+
+ let ast: syn::ItemFn = syn::parse(input).unwrap();
+ let name = ast.ident.clone();
+
+ (quote! {
+ #[allow(non_camel_case_types)]
+ struct #name;
+
+ impl for #name {
+ fn register(self, config: &mut actix_web::dev::ServiceConfig ) {
+ #ast
+ actix_web::dev::HttpServiceFactory::register(
+ actix_web::Resource::new(#path)
+ .guard(actix_web::guard::Post())
+ .to(#name), config);
+ }
+ }
+ })
+ .into()
+}
+
+/// #[put("path")] attribute
+#[proc_macro_attribute]
+pub fn put(args: TokenStream, input: TokenStream) -> TokenStream {
+ let args = parse_macro_input!(args as syn::AttributeArgs);
+ if args.is_empty() {
+ panic!("invalid server definition, expected: #[get(\"some path\")]");
+ }
+
+ // path
+ let path = match args[0] {
+ syn::NestedMeta::Literal(syn::Lit::Str(ref fname)) => {
+ let fname = quote!(#fname).to_string();
+ fname.as_str()[1..fname.len() - 1].to_owned()
+ }
+ _ => panic!("resource path"),
+ };
+
+ let ast: syn::ItemFn = syn::parse(input).unwrap();
+ let name = ast.ident.clone();
+
+ (quote! {
+ #[allow(non_camel_case_types)]
+ struct #name;
+
+ impl for #name {
+ fn register(self, config: &mut actix_web::dev::ServiceConfig ) {
+ #ast
+ actix_web::dev::HttpServiceFactory::register(
+ actix_web::Resource::new(#path)
+ .guard(actix_web::guard::Put())
+ .to(#name), config);
+ }
+ }
+ })
+ .into()
+}
diff --git a/actix-web-codegen/tests/test_macro.rs b/actix-web-codegen/tests/test_macro.rs
new file mode 100644
index 00000000..62b5d618
--- /dev/null
+++ b/actix-web-codegen/tests/test_macro.rs
@@ -0,0 +1,17 @@
+use actix_http::HttpService;
+use actix_http_test::TestServer;
+use actix_web::{get, App, HttpResponse, Responder};
+
+#[get("/test")]
+fn test() -> impl Responder {
+ HttpResponse::Ok()
+}
+
+#[test]
+fn test_body() {
+ let mut srv = TestServer::new(|| HttpService::new(App::new().service(test)));
+
+ let request = srv.get().uri(srv.url("/test")).finish().unwrap();
+ let response = srv.send_request(request).unwrap();
+ assert!(response.status().is_success());
+}
diff --git a/build.rs b/build.rs
deleted file mode 100644
index c8457944..00000000
--- a/build.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-extern crate version_check;
-
-fn main() {
- match version_check::is_min_version("1.26.0") {
- Some((true, _)) => println!("cargo:rustc-cfg=actix_impl_trait"),
- _ => (),
- };
- match version_check::is_nightly() {
- Some(true) => {
- println!("cargo:rustc-cfg=actix_nightly");
- println!("cargo:rustc-cfg=actix_impl_trait");
- }
- Some(false) => (),
- None => (),
- };
-}
diff --git a/examples/basic.rs b/examples/basic.rs
new file mode 100644
index 00000000..756f1b79
--- /dev/null
+++ b/examples/basic.rs
@@ -0,0 +1,49 @@
+use futures::IntoFuture;
+
+use actix_web::{
+ get, middleware, web, App, Error, HttpRequest, HttpResponse, HttpServer,
+};
+
+#[get("/resource1/{name}/index.html")]
+fn index(req: HttpRequest, name: web::Path =
+ BoxedNewService<(), ServiceRequest , ServiceResponse, Error, ()>;
+
+/// Application builder - structure that follows the builder pattern
+/// for building application instances.
+pub struct App{}
\
+ \
+ {}\
+
\n",
+ index_of, index_of, body
+ );
+ Ok(ServiceResponse::new(
+ req.clone(),
+ HttpResponse::Ok()
+ .content_type("text/html; charset=utf-8")
+ .body(html),
+ ))
+}
+
+/// Static files handling
+///
+/// `Files` service must be registered with `App::service()` method.
+///
+/// ```rust
+/// use actix_web::App;
+/// use actix_files as fs;
+///
+/// fn main() {
+/// let app = App::new()
+/// .service(fs::Files::new("/static", "."));
+/// }
+/// ```
+pub struct Files {
+ /// Create new `Files` instance for specified base directory.
+ ///
+ /// `File` uses `ThreadPool` for blocking filesystem operations.
+ /// By default pool with 5x threads of available cpus is used.
+ /// Pool size can be changed by setting ACTIX_CPU_POOL environment variable.
+ pub fn new {
+ Self::with_config(path, dir, DefaultConfig)
+ }
+}
+
+impl for CookieSession
+where
+ S: Service;
+ type Future = FutureResult {
+ service: S,
+ inner: Rc
+where
+ S: Service(actor: A, stream: S) -> impl Stream {
+ stream: S,
+ decoder: Codec,
+ buf: BytesMut,
+ closed: bool,
+}
+
+impl WsStream
+where
+ S: Stream Stream for WsStream
+where
+ S: Stream