1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-12-25 09:30:35 +00:00

refactor static files

This commit is contained in:
Nikolay Kim 2017-12-03 16:57:25 -08:00
parent 7c6faaa8e0
commit 5abc46034a
2 changed files with 197 additions and 107 deletions

279
src/fs.rs
View file

@ -5,13 +5,189 @@ use std::io;
use std::io::Read;
use std::fmt::Write;
use std::fs::{File, DirEntry};
use std::path::PathBuf;
use std::path::{Path, PathBuf};
use std::ops::{Deref, DerefMut};
use mime_guess::get_mime_type;
use route::Handler;
use route::{Handler, FromRequest};
use recognizer::FromParam;
use httprequest::HttpRequest;
use httpresponse::HttpResponse;
use httpcodes::{HTTPOk, HTTPNotFound};
use httpcodes::HTTPOk;
/// A file with an associated name; responds with the Content-Type based on the
/// file extension.
#[derive(Debug)]
pub struct NamedFile(PathBuf, File);
impl NamedFile {
/// Attempts to open a file in read-only mode.
///
/// # Examples
///
/// ```rust
/// use actix_web::fs::NamedFile;
///
/// # #[allow(unused_variables)]
/// let file = NamedFile::open("foo.txt");
/// ```
pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
let file = File::open(path.as_ref())?;
Ok(NamedFile(path.as_ref().to_path_buf(), file))
}
/// Returns reference to the underlying `File` object.
#[inline]
pub fn file(&self) -> &File {
&self.1
}
/// Retrieve the path of this file.
///
/// # Examples
///
/// ```rust
/// # use std::io;
/// use actix_web::fs::NamedFile;
///
/// # #[allow(dead_code)]
/// # fn path() -> io::Result<()> {
/// let file = NamedFile::open("test.txt")?;
/// assert_eq!(file.path().as_os_str(), "foo.txt");
/// # Ok(())
/// # }
/// ```
#[inline]
pub fn path(&self) -> &Path {
self.0.as_path()
}
}
impl Deref for NamedFile {
type Target = File;
fn deref(&self) -> &File {
&self.1
}
}
impl DerefMut for NamedFile {
fn deref_mut(&mut self) -> &mut File {
&mut self.1
}
}
impl FromRequest for NamedFile {
type Item = HttpResponse;
type Error = io::Error;
fn from_request(mut self, _: HttpRequest) -> Result<HttpResponse, io::Error> {
let mut resp = HTTPOk.build();
if let Some(ext) = self.path().extension() {
let mime = get_mime_type(&ext.to_string_lossy());
resp.content_type(format!("{}", mime).as_str());
}
let mut data = Vec::new();
let _ = self.1.read_to_end(&mut data);
Ok(resp.body(data).unwrap())
}
}
/// A directory; responds with the generated directory listing.
#[derive(Debug)]
pub struct Directory{
base: PathBuf,
path: PathBuf
}
impl Directory {
pub fn new(base: PathBuf, path: PathBuf) -> Directory {
Directory {
base: base,
path: path
}
}
fn can_list(&self, entry: &io::Result<DirEntry>) -> bool {
if let Ok(ref entry) = *entry {
if let Some(name) = entry.file_name().to_str() {
if name.starts_with('.') {
return false
}
}
if let Ok(ref md) = entry.metadata() {
let ft = md.file_type();
return ft.is_dir() || ft.is_file() || ft.is_symlink()
}
}
false
}
}
impl FromRequest for Directory {
type Item = HttpResponse;
type Error = io::Error;
fn from_request(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
let index_of = format!("Index of {}", req.path());
let mut body = String::new();
let base = Path::new(req.path());
for entry in self.path.read_dir()? {
if self.can_list(&entry) {
let entry = entry.unwrap();
let p = match entry.path().strip_prefix(&self.base) {
Ok(p) => base.join(p),
Err(_) => continue
};
// show file url as relative to static path
let file_url = format!("{}", p.to_string_lossy());
// if file is a directory, add '/' to the end of the name
if let Ok(metadata) = entry.metadata() {
if metadata.is_dir() {
let _ = write!(body, "<li><a href=\"{}\">{}/</a></li>",
file_url, entry.file_name().to_string_lossy());
} else {
let _ = write!(body, "<li><a href=\"{}\">{}</a></li>",
file_url, entry.file_name().to_string_lossy());
}
} else {
continue
}
}
}
let html = format!("<html>\
<head><title>{}</title></head>\
<body><h1>{}</h1>\
<ul>\
{}\
</ul></body>\n</html>", index_of, index_of, body);
Ok(HTTPOk.build()
.content_type("text/html; charset=utf-8")
.body(html).unwrap())
}
}
/// This enum represents all filesystem elements.
pub enum FilesystemElement {
File(NamedFile),
Directory(Directory),
}
impl FromRequest for FilesystemElement {
type Item = HttpResponse;
type Error = io::Error;
fn from_request(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
match self {
FilesystemElement::File(file) => file.from_request(req),
FilesystemElement::Directory(dir) => dir.from_request(req),
}
}
}
/// Static files handling
///
@ -67,106 +243,25 @@ impl StaticFiles {
}
}
fn index(&self, prefix: &str, relpath: &str, filename: &PathBuf) -> Result<HttpResponse, io::Error> {
let index_of = format!("Index of {}{}", prefix, relpath);
let mut body = String::new();
for entry in filename.read_dir()? {
if self.can_list(&entry) {
let entry = entry.unwrap();
// show file url as relative to static path
let file_url = format!(
"{}{}", prefix,
entry.path().strip_prefix(&self.directory).unwrap().to_string_lossy());
// if file is a directory, add '/' to the end of the name
if let Ok(metadata) = entry.metadata() {
if metadata.is_dir() {
//format!("<li><a href=\"{}\">{}</a></li>", file_url, file_name));
let _ = write!(body, "<li><a href=\"{}\">{}/</a></li>",
file_url, entry.file_name().to_string_lossy());
} else {
// write!(body, "{}/", entry.file_name())
let _ = write!(body, "<li><a href=\"{}\">{}</a></li>",
file_url, entry.file_name().to_string_lossy());
}
} else {
continue
}
}
}
let html = format!("<html>\
<head><title>{}</title></head>\
<body><h1>{}</h1>\
<ul>\
{}\
</ul></body>\n</html>", index_of, index_of, body);
Ok(
HTTPOk.build()
.content_type("text/html; charset=utf-8")
.body(html).unwrap()
)
}
fn can_list(&self, entry: &io::Result<DirEntry>) -> bool {
if let Ok(ref entry) = *entry {
if let Some(name) = entry.file_name().to_str() {
if name.starts_with('.') {
return false
}
}
if let Ok(ref md) = entry.metadata() {
let ft = md.file_type();
return ft.is_dir() || ft.is_file() || ft.is_symlink()
}
}
false
}
}
impl<S> Handler<S> for StaticFiles {
type Result = Result<HttpResponse, io::Error>;
type Result = Result<FilesystemElement, io::Error>;
fn handle(&self, req: HttpRequest<S>) -> Self::Result {
if !self.accessible {
Ok(HTTPNotFound.into())
Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
} else {
let mut hidden = false;
let filepath = req.path()[req.prefix_len()..]
.split('/').filter(|s| {
if s.starts_with('.') {
hidden = true;
}
!s.is_empty()
})
.fold(String::new(), |s, i| {s + "/" + i});
// hidden file
if hidden {
return Ok(HTTPNotFound.into())
}
let relpath = PathBuf::from_param(&req.path()[req.prefix_len()..])
.map_err(|_| io::Error::new(io::ErrorKind::NotFound, "not found"))?;
// full filepath
let idx = if filepath.starts_with('/') { 1 } else { 0 };
let filename = self.directory.join(&filepath[idx..]).canonicalize()?;
let path = self.directory.join(&relpath).canonicalize()?;
if filename.is_dir() {
self.index(&req.path()[..req.prefix_len()], &filepath[idx..], &filename)
if path.is_dir() {
Ok(FilesystemElement::Directory(Directory::new(self.directory.clone(), path)))
} else {
let mut resp = HTTPOk.build();
if let Some(ext) = filename.extension() {
let mime = get_mime_type(&ext.to_string_lossy());
resp.content_type(format!("{}", mime).as_str());
}
match File::open(filename) {
Ok(mut file) => {
let mut data = Vec::new();
let _ = file.read_to_end(&mut data);
Ok(resp.body(data).unwrap())
},
Err(err) => Err(err),
}
Ok(FilesystemElement::File(NamedFile::open(path)?))
}
}
}

View file

@ -101,27 +101,22 @@ impl From<HttpResponse> for Reply {
}
}
impl<T: Into<HttpResponse>, E: Into<Error>> FromRequest for Result<T, E> {
type Item = Reply;
type Error = E;
impl<T: FromRequest, E: Into<Error>> FromRequest for Result<T, E>
{
type Item = <T as FromRequest>::Item;
type Error = Error;
fn from_request(self, _: HttpRequest) -> Result<Reply, Self::Error> {
fn from_request(self, req: HttpRequest) -> Result<Self::Item, Self::Error> {
match self {
Ok(val) => Ok(Reply(ReplyItem::Message(val.into()))),
Err(err) => Err(err),
Ok(val) => match val.from_request(req) {
Ok(val) => Ok(val),
Err(err) => Err(err.into()),
},
Err(err) => Err(err.into()),
}
}
}
impl<E: Into<Error>> FromRequest for Result<Reply, E> {
type Item = Reply;
type Error = E;
fn from_request(self, _: HttpRequest) -> Result<Reply, E> {
self
}
}
impl<E: Into<Error>> From<Result<Reply, E>> for Reply {
fn from(res: Result<Reply, E>) -> Self {
match res {