mirrors/actix-web
1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-06-02 21:39:26 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1541 from JohnTitor/backport-files

Browse source 
files: Bump up to 0.2.2
This commit is contained in:
Yuki Okushi 2020-05-27 00:37:29 +09:00 committed by GitHub
parent 12eccf40e1 55d79cc1b2
commit d92d53a4f5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 80 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
actix-files/CHANGES.md
View file

@ -1,5 +1,13 @@
# Changes # Changes
## [0.2.2] - 2020-05-26
* Minimize `futures` dependency
* Support sending Content-Length when Content-Range is specified [#1496]
* Update `actix-web` to 2.0.0
[#1496]: https://github.com/actix/actix-web/issues/1496
## [0.2.1] - 2019-12-22 ## [0.2.1] - 2019-12-22
* Use the same format for file URLs regardless of platforms * Use the same format for file URLs regardless of platforms

9
actix-files/Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "actix-files" name = "actix-files"
version = "0.2.1" version = "0.2.2"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"] authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Static files support for actix web." description = "Static files support for actix web."
readme = "README.md" readme = "README.md"
@ -18,12 +18,13 @@ name = "actix_files"
path = "src/lib.rs" path = "src/lib.rs"
[dependencies] [dependencies]
actix-web = { version = "2.0.0-rc", default-features = false } actix-web = { version = "2.0.0", default-features = false }
actix-http = "1.0.1" actix-http = "1.0.1"
actix-service = "1.0.1" actix-service = "1.0.1"
bitflags = "1" bitflags = "1"
bytes = "0.5.3" bytes = "0.5.3"
futures = "0.3.1" futures-core = { version = "0.3.5", default-features = false }
futures-util = { version = "0.3.5", default-features = false }
derive_more = "0.99.2" derive_more = "0.99.2"
log = "0.4" log = "0.4"
mime = "0.3" mime = "0.3"
@ -33,4 +34,4 @@ v_htmlescape = "0.4"
[dev-dependencies] [dev-dependencies]
actix-rt = "1.0.0" actix-rt = "1.0.0"
actix-web = { version = "2.0.0-rc", features=["openssl"] } actix-web = { version = "2.0.0", features = ["openssl"] }

1
actix-files/src/error.rs
View file

@ -5,6 +5,7 @@ use derive_more::Display;
#[derive(Display, Debug, PartialEq)] #[derive(Display, Debug, PartialEq)]
pub enum FilesError { pub enum FilesError {
/// Path is not a directory /// Path is not a directory
#[allow(dead_code)]
#[display(fmt = "Path is not a directory. Unable to serve static files")] #[display(fmt = "Path is not a directory. Unable to serve static files")]
IsNotDirectory, IsNotDirectory,

165
actix-files/src/lib.rs
View file

@ -24,8 +24,8 @@ use actix_web::http::header::{self, DispositionType};
use actix_web::http::Method; use actix_web::http::Method;
use actix_web::{web, FromRequest, HttpRequest, HttpResponse}; use actix_web::{web, FromRequest, HttpRequest, HttpResponse};
use bytes::Bytes; use bytes::Bytes;
use futures::future::{ok, ready, Either, FutureExt, LocalBoxFuture, Ready}; use futures_core::Stream;
use futures::Stream; use futures_util::future::{ok, ready, Either, FutureExt, LocalBoxFuture, Ready};
use mime; use mime;
use mime_guess::from_ext; use mime_guess::from_ext;
use percent_encoding::{utf8_percent_encode, CONTROLS}; use percent_encoding::{utf8_percent_encode, CONTROLS};
@ -521,7 +521,7 @@ impl Service for FilesService {
Err(e) => return Either::Left(ok(req.error_response(e))), Err(e) => return Either::Left(ok(req.error_response(e))),
}; };
// full filepath // full file path
let path = match self.directory.join(&real_path.0).canonicalize() { let path = match self.directory.join(&real_path.0).canonicalize() {
Ok(path) => path, Ok(path) => path,
Err(e) => return self.handle_err(e, req), Err(e) => return self.handle_err(e, req),
@ -952,135 +952,92 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_named_file_content_range_headers() { async fn test_named_file_content_range_headers() {
let mut srv = test::init_service( let srv = test::start(|| {
App::new().service(Files::new("/test", ".").index_file("tests/test.binary")), App::new().service(Files::new("/", "."))
) });
.await;
// Valid range header // Valid range header
let request = TestRequest::get() let response = srv
.uri("/t%65st/tests/test.binary") .get("/tests/test.binary")
.header(header::RANGE, "bytes=10-20") .header(header::RANGE, "bytes=10-20")
.to_request(); .send()
.await
let response = test::call_service(&mut srv, request).await;
let contentrange = response
.headers()
.get(header::CONTENT_RANGE)
.unwrap()
.to_str()
.unwrap(); .unwrap();
let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
assert_eq!(contentrange, "bytes 10-20/100"); assert_eq!(content_range.to_str().unwrap(), "bytes 10-20/100");
// Invalid range header // Invalid range header
let request = TestRequest::get() let response = srv
.uri("/t%65st/tests/test.binary") .get("/tests/test.binary")
.header(header::RANGE, "bytes=10-5") .header(header::RANGE, "bytes=10-5")
.to_request(); .send()
let response = test::call_service(&mut srv, request).await; .await
let contentrange = response
.headers()
.get(header::CONTENT_RANGE)
.unwrap()
.to_str()
.unwrap(); .unwrap();
let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
assert_eq!(contentrange, "bytes */100"); assert_eq!(content_range.to_str().unwrap(), "bytes */100");
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_named_file_content_length_headers() { async fn test_named_file_content_length_headers() {
// use actix_web::body::{MessageBody, ResponseBody}; let srv = test::start(|| {
App::new().service(Files::new("/", "."))
let mut srv = test::init_service( });
App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
)
.await;
// Valid range header // Valid range header
let request = TestRequest::get() let response = srv
.uri("/t%65st/tests/test.binary") .get("/tests/test.binary")
.header(header::RANGE, "bytes=10-20") .header(header::RANGE, "bytes=10-20")
.to_request(); .send()
let _response = test::call_service(&mut srv, request).await; .await
.unwrap();
let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(content_length.to_str().unwrap(), "11");
// let contentlength = response // Valid range header, starting from 0
// .headers() let response = srv
// .get(header::CONTENT_LENGTH) .get("/tests/test.binary")
// .unwrap() .header(header::RANGE, "bytes=0-20")
// .to_str() .send()
// .unwrap(); .await
// assert_eq!(contentlength, "11"); .unwrap();
let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
// Invalid range header assert_eq!(content_length.to_str().unwrap(), "21");
let request = TestRequest::get()
.uri("/t%65st/tests/test.binary")
.header(header::RANGE, "bytes=10-8")
.to_request();
let response = test::call_service(&mut srv, request).await;
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
// Without range header // Without range header
let request = TestRequest::get() let mut response = srv.get("/tests/test.binary").send().await.unwrap();
.uri("/t%65st/tests/test.binary") let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
// .no_default_headers() assert_eq!(content_length.to_str().unwrap(), "100");
.to_request();
let _response = test::call_service(&mut srv, request).await;
// let contentlength = response // Should be no transfer-encoding
// .headers() let transfer_encoding = response.headers().get(header::TRANSFER_ENCODING);
// .get(header::CONTENT_LENGTH) assert!(transfer_encoding.is_none());
// .unwrap()
// .to_str()
// .unwrap();
// assert_eq!(contentlength, "100");
// chunked // Check file contents
let request = TestRequest::get() let bytes = response.body().await.unwrap();
.uri("/t%65st/tests/test.binary")
.to_request();
let response = test::call_service(&mut srv, request).await;
// with enabled compression
// {
// let te = response
// .headers()
// .get(header::TRANSFER_ENCODING)
// .unwrap()
// .to_str()
// .unwrap();
// assert_eq!(te, "chunked");
// }
let bytes = test::read_body(response).await;
let data = Bytes::from(fs::read("tests/test.binary").unwrap()); let data = Bytes::from(fs::read("tests/test.binary").unwrap());
assert_eq!(bytes, data); assert_eq!(bytes, data);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_head_content_length_headers() { async fn test_head_content_length_headers() {
let mut srv = test::init_service( let srv = test::start(|| {
App::new().service(Files::new("test", ".").index_file("tests/test.binary")), App::new().service(Files::new("/", "."))
) });
.await;
// Valid range header let response = srv
let request = TestRequest::default() .head("/tests/test.binary")
.method(Method::HEAD) .send()
.uri("/t%65st/tests/test.binary") .await
.to_request(); .unwrap();
let _response = test::call_service(&mut srv, request).await;
// TODO: fix check let content_length = response
// let contentlength = response .headers()
// .headers() .get(header::CONTENT_LENGTH)
// .get(header::CONTENT_LENGTH) .unwrap()
// .unwrap() .to_str()
// .to_str() .unwrap();
// .unwrap();
// assert_eq!(contentlength, "100"); assert_eq!(content_length, "100");
} }
#[actix_rt::test] #[actix_rt::test]

9
actix-files/src/named.rs
View file

@ -18,7 +18,7 @@ use actix_web::http::header::{
}; };
use actix_web::http::{ContentEncoding, StatusCode}; use actix_web::http::{ContentEncoding, StatusCode};
use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder}; use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};
use futures::future::{ready, Ready}; use futures_util::future::{ready, Ready};
use crate::range::HttpRange; use crate::range::HttpRange;
use crate::ChunkedReadFile; use crate::ChunkedReadFile;
@ -388,11 +388,12 @@ impl NamedFile {
fut: None, fut: None,
counter: 0, counter: 0,
}; };
if offset != 0 || length != self.md.len() { if offset != 0 || length != self.md.len() {
Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader)) resp.status(StatusCode::PARTIAL_CONTENT);
} else {
Ok(resp.body(SizedStream::new(length, reader)))
} }
Ok(resp.body(SizedStream::new(length, reader)))
} }
} }