static-web-server.git

author	Jose Quintana <joseluisquintana20@gmail.com>	2022-05-23 22:38:43.0 +00:00:00
committer	Jose Quintana <joseluisquintana20@gmail.com>	2022-05-23 22:38:43.0 +00:00:00
commit	b0499dfefd7d4f1b78a3373928f9c7b399022717 [patch]
tree	05d0b7be1c9eae90b03f7bf8d1566df81f9fc8e6
parent	f0dba0ba251bb955883ed7c33fb998e6fecbcd5e
download	b0499dfefd7d4f1b78a3373928f9c7b399022717.tar.gz

feat: log request file with its remote address if available

example:

static-web-server -a 0.0.0.0 -p 8080 -d docker/public/ -g info
2022-05-23T22:24:50.519540Z  INFO static_web_server::handler: incoming request: method=GET uri=/ remote_addr=192.168.1.126:57625
2022-05-23T22:25:26.516841Z  INFO static_web_server::handler: incoming request: method=GET uri=/favicon.ico remote_addr=192.168.1.126:57625

resolves #111

Diff

 src/handler.rs | 12 +++++++++++-
 src/service.rs | 17 ++++++++++-------
 2 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/src/handler.rs b/src/handler.rs
index a9ab4f7..bb311b4 100644
--- a/src/handler.rs
+++ b/src/handler.rs
@@ -1,5 +1,5 @@
use hyper::{header::WWW_AUTHENTICATE, Body, Method, Request, Response, StatusCode};
use std::{future::Future, path::PathBuf, sync::Arc};
use std::{future::Future, net::SocketAddr, path::PathBuf, sync::Arc};

use crate::{
    basic_auth, compression, control_headers, cors, custom_headers, error_page, fallback_page,
@@ -35,6 +35,7 @@ impl RequestHandler {
    pub fn handle<'a>(
        &'a self,
        req: &'a mut Request<Body>,
        remote_addr: Option<SocketAddr>,
    ) -> impl Future<Output = Result<Response<Body>, Error>> + Send + 'a {
        let method = req.method();
        let headers = req.headers();
@@ -48,6 +49,15 @@ impl RequestHandler {

        let mut cors_headers: Option<http::HeaderMap> = None;

        // Log request information with its remote address
        let remote_addr = remote_addr.map_or("".to_owned(), |v| v.to_string());
        tracing::info!(
            "incoming request: method={} uri={} remote_addr={}",
            method,
            uri,
            remote_addr,
        );

        async move {
            // Check for disallowed HTTP methods and reject request accordently
            if !(method == Method::GET || method == Method::HEAD || method == Method::OPTIONS) {
diff --git a/src/service.rs b/src/service.rs
index 7f5aa8b..315fd16 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -1,12 +1,12 @@
use hyper::{service::Service, Body, Request, Response};
use std::convert::Infallible;
use std::future::{ready, Future, Ready};
use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};

use crate::handler::RequestHandler;
use crate::Error;
use crate::{handler::RequestHandler, transport::Transport, Error};

/// It defines the router service which is the main entry point for Hyper Server.
pub struct RouterService {
@@ -21,7 +21,7 @@ impl RouterService {
    }
}

impl<T> Service<T> for RouterService {
impl<T: Transport + Send + 'static> Service<&T> for RouterService {
    type Response = RequestService;
    type Error = Infallible;
    type Future = Ready<Result<Self::Response, Self::Error>>;
@@ -30,14 +30,15 @@ impl<T> Service<T> for RouterService {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, _: T) -> Self::Future {
        ready(Ok(self.builder.build()))
    fn call(&mut self, conn: &T) -> Self::Future {
        ready(Ok(self.builder.build(conn.remote_addr())))
    }
}

/// It defines a Hyper service request which delegates a request handler.
pub struct RequestService {
    handler: Arc<RequestHandler>,
    remote_addr: Option<SocketAddr>,
}

impl Service<Request<Body>> for RequestService {
@@ -51,7 +52,8 @@ impl Service<Request<Body>> for RequestService {

    fn call(&mut self, mut req: Request<Body>) -> Self::Future {
        let handler = self.handler.clone();
        Box::pin(async move { handler.handle(&mut req).await })
        let remote_addr = self.remote_addr;
        Box::pin(async move { handler.handle(&mut req, remote_addr).await })
    }
}

@@ -67,9 +69,10 @@ impl RequestServiceBuilder {
        }
    }

    pub fn build(&self) -> RequestService {
    pub fn build(&self, remote_addr: Option<SocketAddr>) -> RequestService {
        RequestService {
            handler: self.handler.clone(),
            remote_addr,
        }
    }
}