serv/dufs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: improve code quality

Browse source
This commit is contained in:
sigoden 2022-05-31 05:49:42 +08:00
parent 54df4633e1
commit fb03f7ddb8
3 changed files with 203 additions and 178 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/assets/index.html
View file

@ -4,7 +4,7 @@
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
__SLOB__
__SLOT__
</head>
<body>
<div class="head">

98
src/assets/index.js
View file

@ -1,6 +1,6 @@
var $toolbox, $tbody, $breadcrumb, $uploaders, $uploadControl;
var uploaderIdx = 0;
var baseDir;
let $tbody, $uploaders;
let uploaderIdx = 0;
let baseDir;
class Uploader {
idx = 0;
@ -12,8 +12,8 @@ class Uploader {
}
upload() {
var { file, idx } = this;
var url = getUrl(file.name);
const { file, idx } = this;
let url = getUrl(file.name);
if (file.name == baseDir + ".zip") {
url += "?unzip";
}
@ -24,35 +24,45 @@ class Uploader {
</div>`);
this.$elem = document.getElementById(`file${idx}`);
var ajax = new XMLHttpRequest();
const ajax = new XMLHttpRequest();
ajax.upload.addEventListener("progress", e => this.progress(e), false);
ajax.addEventListener("load", e => this.complete(e), false);
ajax.addEventListener("error", e => this.fail(e), false);
ajax.addEventListener("abort", e => this.fail(e), false);
ajax.addEventListener("readystatechange", () => {
console.log(ajax.readyState, ajax.status)
if(ajax.readyState === 4) {
if (ajax.status == 200) {
this.complete();
} else {
this.fail();
}
}
})
ajax.addEventListener("error", () => this.fail(), false);
ajax.addEventListener("abort", () => this.fail(), false);
ajax.open("PUT", url);
ajax.send(file);
}
progress(event) {
var percent = (event.loaded / event.total) * 100;
const percent = (event.loaded / event.total) * 100;
this.$elem.innerHTML = `${this.file.name} (${percent.toFixed(2)}%)`;
}
complete(event) {
complete() {
this.$elem.innerHTML = `${this.file.name}`;
}
fail(event) {
fail() {
this.$elem.innerHTML = `<strike>${this.file.name}</strike>`;
}
}
function addBreadcrumb(value) {
var parts = value.split("/").filter(v => !!v);
var len = parts.length;
var path = "";
for (var i = 0; i < len; i++) {
var name = parts[i];
const $breadcrumb = document.querySelector(".breadcrumb");
const parts = value.split("/").filter(v => !!v);
const len = parts.length;
let path = "";
for (let i = 0; i < len; i++) {
const name = parts[i];
if (i > 0) {
path += "/" + name;
}
@ -69,9 +79,9 @@ function addBreadcrumb(value) {
}
function addPath(file, index) {
var url = getUrl(file.name)
var actionDelete = "";
var actionDownload = "";
const url = getUrl(file.name)
let actionDelete = "";
let actionDownload = "";
if (file.path_type.endsWith("Dir")) {
actionDownload = `
<div class="action-btn">
@ -93,7 +103,7 @@ function addPath(file, index) {
<svg width="16" height="16" fill="currentColor"viewBox="0 0 16 16"><path d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z"/><path d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z"/></svg>
</div>`;
}
var actionCell = `
let actionCell = `
<td class="cell-actions">
${actionDownload}
${actionDelete}
@ -112,21 +122,25 @@ ${actionCell}
}
async function deletePath(index) {
var file = DATA.paths[index];
const file = DATA.paths[index];
if (!file) return;
var ajax = new XMLHttpRequest();
ajax.open("DELETE", getUrl(file.name));
ajax.addEventListener("readystatechange", function() {
if(ajax.readyState === 4 && ajax.status === 200) {
document.getElementById(`addPath${index}`).remove();
}
try {
const res = await fetch(getUrl(file.name), {
method: "DELETE",
});
ajax.send();
if (res.status === 200) {
document.getElementById(`addPath${index}`).remove();
} else {
throw new Error(await res.text())
}
} catch (err) {
alert(`Fail to delete ${file.name}, ${err.message}`);
}
}
function getUrl(name) {
var url = location.href.split('?')[0];
let url = location.href.split('?')[0];
if (!url.endsWith("/")) url += "/";
url += encodeURI(name);
return url;
@ -147,12 +161,12 @@ function getSvg(path_type) {
function formatMtime(mtime) {
if (!mtime) return ""
var date = new Date(mtime);
var year = date.getFullYear();
var month = padZero(date.getMonth() + 1, 2);
var day = padZero(date.getDate(), 2);
var hours = padZero(date.getHours(), 2);
var minutes = padZero(date.getMinutes(), 2);
const date = new Date(mtime);
const year = date.getFullYear();
const month = padZero(date.getMonth() + 1, 2);
const day = padZero(date.getDate(), 2);
const hours = padZero(date.getHours(), 2);
const minutes = padZero(date.getMinutes(), 2);
return `${year}/${month}/${day} ${hours}:${minutes}`;
}
@ -162,17 +176,15 @@ function padZero(value, size) {
function formatSize(size) {
if (!size) return ""
var sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
if (size == 0) return '0 Byte';
var i = parseInt(Math.floor(Math.log(size) / Math.log(1024)));
const i = parseInt(Math.floor(Math.log(size) / Math.log(1024)));
return Math.round(size / Math.pow(1024, i), 2) + ' ' + sizes[i];
}
function ready() {
$toolbox = document.querySelector(".toolbox");
$tbody = document.querySelector(".main tbody");
$breadcrumb = document.querySelector(".breadcrumb");
$uploaders = document.querySelector(".uploaders");
addBreadcrumb(DATA.breadcrumb);
@ -180,10 +192,10 @@ function ready() {
if (!DATA.readonly) {
document.querySelector(".upload-control").classList.remove(["hidden"]);
document.getElementById("file").addEventListener("change", e => {
var files = e.target.files;
for (var file of files) {
const files = e.target.files;
for (let file of files) {
uploaderIdx += 1;
var uploader = new Uploader(uploaderIdx, file);
const uploader = new Uploader(uploaderIdx, file);
uploader.upload();
}
});

277
src/server.rs
View file

@ -7,8 +7,8 @@ use async_zip::Compression;
use futures::stream::StreamExt;
use futures::TryStreamExt;
use headers::{
AccessControlAllowHeaders, AccessControlAllowOrigin, ContentType, ETag, HeaderMapExt,
IfModifiedSince, IfNoneMatch, LastModified,
AccessControlAllowHeaders, AccessControlAllowOrigin, ContentType, ETag, HeaderMap,
HeaderMapExt, IfModifiedSince, IfNoneMatch, LastModified,
};
use hyper::header::{HeaderValue, ACCEPT, CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE};
use hyper::service::{make_service_fn, service_fn};
@ -28,15 +28,6 @@ use tokio_util::io::{ReaderStream, StreamReader};
type Request = hyper::Request<Body>;
type Response = hyper::Response<Body>;
macro_rules! status_code {
($status:expr) => {
hyper::Response::builder()
.status($status)
.body($status.canonical_reason().unwrap_or_default().into())
.unwrap()
};
}
const INDEX_HTML: &str = include_str!("assets/index.html");
const INDEX_CSS: &str = include_str!("assets/index.css");
const INDEX_JS: &str = include_str!("assets/index.js");
@ -76,11 +67,16 @@ impl InnerService {
let method = req.method().clone();
let uri = req.uri().clone();
let cors = self.args.cors;
let mut res = self
.handle(req)
.await
.unwrap_or_else(|_| status_code!(StatusCode::INTERNAL_SERVER_ERROR));
let mut res = self.handle(req).await.unwrap_or_else(|e| {
let mut res = Response::default();
*res.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
*res.body_mut() = Body::from(e.to_string());
res
});
info!(r#""{} {}" - {}"#, method, uri, res.status());
if cors {
add_cors(&mut res);
}
@ -88,74 +84,77 @@ impl InnerService {
}
pub async fn handle(self: Arc<Self>, req: Request) -> BoxResult<Response> {
if !self.auth_guard(&req).unwrap_or_default() {
let mut res = status_code!(StatusCode::UNAUTHORIZED);
res.headers_mut()
.insert(WWW_AUTHENTICATE, HeaderValue::from_static("Basic"));
let mut res = Response::default();
if !self.auth_guard(&req, &mut res) {
return Ok(res);
}
let path = req.uri().path();
let filepath = match self.extract_path(path) {
Some(v) => v,
None => {
*res.status_mut() = StatusCode::FORBIDDEN;
return Ok(res);
}
};
let filepath = filepath.as_path();
let query = req.uri().query().unwrap_or_default();
let meta = fs::metadata(filepath).await.ok();
let is_miss = meta.is_none();
let is_dir = meta.map(|v| v.is_dir()).unwrap_or_default();
let readonly = self.args.readonly;
match *req.method() {
Method::GET => self.handle_static(req).await,
Method::PUT => {
if self.args.readonly {
return Ok(status_code!(StatusCode::FORBIDDEN));
Method::GET if is_dir && query == "zip" => {
self.handle_zip_dir(filepath, &mut res).await?
}
self.handle_upload(req).await
Method::GET if is_dir && query.starts_with("q=") => {
self.handle_query_dir(filepath, &query[3..], &mut res)
.await?
}
Method::OPTIONS => Ok(status_code!(StatusCode::NO_CONTENT)),
Method::DELETE => self.handle_delete(req).await,
_ => Ok(status_code!(StatusCode::NOT_FOUND)),
Method::GET if !is_dir && !is_miss => {
self.handle_send_file(filepath, req.headers(), &mut res)
.await?
}
Method::GET if is_miss && path.ends_with('/') => {
self.handle_ls_dir(filepath, false, &mut res).await?
}
Method::GET => self.handle_ls_dir(filepath, true, &mut res).await?,
Method::OPTIONS => *res.status_mut() = StatusCode::NO_CONTENT,
Method::PUT if readonly => *res.status_mut() = StatusCode::FORBIDDEN,
Method::PUT => self.handle_upload(filepath, req, &mut res).await?,
Method::DELETE if !is_miss && readonly => *res.status_mut() = StatusCode::FORBIDDEN,
Method::DELETE if !is_miss => self.handle_delete(filepath, is_dir).await?,
_ => *res.status_mut() = StatusCode::NOT_FOUND,
}
async fn handle_static(&self, req: Request) -> BoxResult<Response> {
let req_path = req.uri().path();
let path = match self.get_file_path(req_path)? {
Some(path) => path,
None => return Ok(status_code!(StatusCode::FORBIDDEN)),
};
match fs::metadata(&path).await {
Ok(meta) => {
if meta.is_dir() {
let req_query = req.uri().query().unwrap_or_default();
if req_query == "zip" {
return self.handle_send_dir_zip(path.as_path()).await;
}
if let Some(q) = req_query.strip_prefix("q=") {
return self.handle_query_dir(path.as_path(), q).await;
}
self.handle_ls_dir(path.as_path(), true).await
} else {
self.handle_send_file(&req, path.as_path()).await
}
}
Err(_) => {
if req_path.ends_with('/') {
self.handle_ls_dir(path.as_path(), false).await
} else {
Ok(status_code!(StatusCode::NOT_FOUND))
}
}
}
Ok(res)
}
async fn handle_upload(&self, mut req: Request) -> BoxResult<Response> {
let forbidden = status_code!(StatusCode::FORBIDDEN);
let path = match self.get_file_path(req.uri().path())? {
Some(path) => path,
None => return Ok(forbidden),
};
match path.parent() {
async fn handle_upload(
&self,
path: &Path,
mut req: Request,
res: &mut Response,
) -> BoxResult<()> {
let ensure_parent = match path.parent() {
Some(parent) => match fs::metadata(parent).await {
Ok(meta) => {
if !meta.is_dir() {
return Ok(forbidden);
Ok(meta) => meta.is_dir(),
Err(_) => {
fs::create_dir_all(parent).await?;
true
}
}
Err(_) => fs::create_dir_all(parent).await?,
},
None => return Ok(forbidden),
None => false,
};
if !ensure_parent {
*res.status_mut() = StatusCode::FORBIDDEN;
return Ok(());
}
let mut file = fs::File::create(&path).await?;
@ -194,39 +193,37 @@ impl InnerService {
fs::remove_file(&path).await?;
}
return Ok(status_code!(StatusCode::OK));
Ok(())
}
async fn handle_delete(&self, req: Request) -> BoxResult<Response> {
let path = match self.get_file_path(req.uri().path())? {
Some(path) => path,
None => return Ok(status_code!(StatusCode::FORBIDDEN)),
};
let meta = fs::metadata(&path).await?;
if meta.is_file() {
fs::remove_file(path).await?;
} else {
fs::remove_dir_all(path).await?;
async fn handle_delete(&self, path: &Path, is_dir: bool) -> BoxResult<()> {
match is_dir {
true => fs::remove_dir_all(path).await?,
false => fs::remove_file(path).await?,
}
Ok(status_code!(StatusCode::OK))
Ok(())
}
async fn handle_ls_dir(&self, path: &Path, exist: bool) -> BoxResult<Response> {
async fn handle_ls_dir(&self, path: &Path, exist: bool, res: &mut Response) -> BoxResult<()> {
let mut paths: Vec<PathItem> = vec![];
if exist {
let mut rd = fs::read_dir(path).await?;
while let Some(entry) = rd.next_entry().await? {
let entry_path = entry.path();
if let Ok(item) = get_path_item(entry_path, path.to_path_buf()).await {
if let Ok(item) = to_pathitem(entry_path, path.to_path_buf()).await {
paths.push(item);
}
}
}
self.send_index(path, paths)
self.send_index(path, paths, res)
}
async fn handle_query_dir(&self, path: &Path, q: &str) -> BoxResult<Response> {
async fn handle_query_dir(
&self,
path: &Path,
query: &str,
res: &mut Response,
) -> BoxResult<()> {
let mut paths: Vec<PathItem> = vec![];
let mut walkdir = WalkDir::new(path);
while let Some(entry) = walkdir.next().await {
@ -235,22 +232,22 @@ impl InnerService {
.file_name()
.to_string_lossy()
.to_lowercase()
.contains(&q.to_lowercase())
.contains(&query.to_lowercase())
{
continue;
}
if fs::symlink_metadata(entry.path()).await.is_err() {
continue;
}
if let Ok(item) = get_path_item(entry.path(), path.to_path_buf()).await {
if let Ok(item) = to_pathitem(entry.path(), path.to_path_buf()).await {
paths.push(item);
}
}
}
self.send_index(path, paths)
self.send_index(path, paths, res)
}
async fn handle_send_dir_zip(&self, path: &Path) -> BoxResult<Response> {
async fn handle_zip_dir(&self, path: &Path, res: &mut Response) -> BoxResult<()> {
let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
let path = path.to_owned();
tokio::spawn(async move {
@ -259,16 +256,20 @@ impl InnerService {
}
});
let stream = ReaderStream::new(reader);
let body = Body::wrap_stream(stream);
Ok(Response::new(body))
*res.body_mut() = Body::wrap_stream(stream);
Ok(())
}
async fn handle_send_file(&self, req: &Request, path: &Path) -> BoxResult<Response> {
async fn handle_send_file(
&self,
path: &Path,
headers: &HeaderMap<HeaderValue>,
res: &mut Response,
) -> BoxResult<()> {
let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);
let (file, meta) = (file?, meta?);
let mut res = Response::default();
if let Ok(mtime) = meta.modified() {
let timestamp = get_timestamp(&mtime);
let timestamp = to_timestamp(&mtime);
let size = meta.len();
let etag = format!(r#""{}-{}""#, timestamp, size)
.parse::<ETag>()
@ -276,10 +277,9 @@ impl InnerService {
let last_modified = LastModified::from(mtime);
let fresh = {
// `If-None-Match` takes presedence over `If-Modified-Since`.
if let Some(if_none_match) = req.headers().typed_get::<IfNoneMatch>() {
if let Some(if_none_match) = headers.typed_get::<IfNoneMatch>() {
!if_none_match.precondition_passes(&etag)
} else if let Some(if_modified_since) = req.headers().typed_get::<IfModifiedSince>()
{
} else if let Some(if_modified_since) = headers.typed_get::<IfModifiedSince>() {
!if_modified_since.is_modified(mtime)
} else {
false
@ -289,7 +289,7 @@ impl InnerService {
res.headers_mut().typed_insert(etag);
if fresh {
*res.status_mut() = StatusCode::NOT_MODIFIED;
return Ok(res);
return Ok(());
}
}
if let Some(mime) = mime_guess::from_path(&path).first() {
@ -298,10 +298,16 @@ impl InnerService {
let stream = FramedRead::new(file, BytesCodec::new());
let body = Body::wrap_stream(stream);
*res.body_mut() = body;
Ok(res)
Ok(())
}
fn send_index(&self, path: &Path, mut paths: Vec<PathItem>) -> BoxResult<Response> {
fn send_index(
&self,
path: &Path,
mut paths: Vec<PathItem>,
res: &mut Response,
) -> BoxResult<()> {
paths.sort_unstable();
let rel_path = match self.args.path.parent() {
Some(p) => path.strip_prefix(p).unwrap(),
@ -314,10 +320,10 @@ impl InnerService {
};
let data = serde_json::to_string(&data).unwrap();
let output = INDEX_HTML.replace(
"__SLOB__",
"__SLOT__",
&format!(
r#"
<title>Files in {} - Duf/</title>
<title>Files in {}/ - Duf</title>
<style>{}</style>
<script>var DATA = {}; {}</script>
"#,
@ -327,44 +333,51 @@ impl InnerService {
INDEX_JS
),
);
*res.body_mut() = output.into();
Ok(Response::new(output.into()))
Ok(())
}
fn auth_guard(&self, req: &Request) -> BoxResult<bool> {
if let Some(auth) = &self.args.auth {
if let Some(value) = req.headers().get("Authorization") {
let value = value.to_str()?;
let value = if value.contains("Basic ") {
&value[6..]
} else {
return Ok(false);
fn auth_guard(&self, req: &Request, res: &mut Response) -> bool {
let pass = {
match &self.args.auth {
None => true,
Some(auth) => match req.headers().get("Authorization") {
Some(value) => match value.to_str().ok().map(|v| {
let mut it = v.split(' ');
(it.next(), it.next())
}) {
Some((Some("Basic "), Some(tail))) => base64::decode(tail)
.ok()
.and_then(|v| String::from_utf8(v).ok())
.map(|v| v.as_str() == auth)
.unwrap_or_default(),
_ => false,
},
None => self.args.no_auth_read && req.method() == Method::GET,
},
}
};
let value = base64::decode(value)?;
let value = std::str::from_utf8(&value)?;
return Ok(value == auth);
} else {
if self.args.no_auth_read && req.method() == Method::GET {
return Ok(true);
if !pass {
*res.status_mut() = StatusCode::UNAUTHORIZED;
res.headers_mut()
.insert(WWW_AUTHENTICATE, HeaderValue::from_static("Basic"));
}
return Ok(false);
}
}
Ok(true)
pass
}
fn get_file_path(&self, path: &str) -> BoxResult<Option<PathBuf>> {
let decoded_path = percent_decode(path[1..].as_bytes()).decode_utf8()?;
fn extract_path(&self, path: &str) -> Option<PathBuf> {
let decoded_path = percent_decode(path[1..].as_bytes()).decode_utf8().ok()?;
let slashes_switched = if cfg!(windows) {
decoded_path.replace('/', "\\")
} else {
decoded_path.into_owned()
};
let path = self.args.path.join(&slashes_switched);
if path.starts_with(&self.args.path) {
Ok(Some(path))
let full_path = self.args.path.join(&slashes_switched);
if full_path.starts_with(&self.args.path) {
Some(full_path)
} else {
Ok(None)
None
}
}
}
@ -392,7 +405,7 @@ enum PathType {
SymlinkFile,
}
async fn get_path_item<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathItem> {
async fn to_pathitem<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathItem> {
let path = path.as_ref();
let rel_path = path.strip_prefix(base_path).unwrap();
let (meta, meta2) = tokio::join!(fs::metadata(&path), fs::symlink_metadata(&path));
@ -405,7 +418,7 @@ async fn get_path_item<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathI
(true, false) => PathType::SymlinkFile,
(false, false) => PathType::File,
};
let mtime = get_timestamp(&meta.modified()?);
let mtime = to_timestamp(&meta.modified()?);
let size = match path_type {
PathType::Dir | PathType::SymlinkDir => None,
PathType::File | PathType::SymlinkFile => Some(meta.len()),
@ -419,7 +432,7 @@ async fn get_path_item<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathI
})
}
fn get_timestamp(time: &SystemTime) -> u64 {
fn to_timestamp(time: &SystemTime) -> u64 {
time.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_millis() as u64