bak

Author: timzaak

server/src/admin_server.rs

@@ -260,8 +260,6 @@ pub mod service {
                 _ => Ok(warp::reply::json(&domain_info).into_response()),
             },
             Err(e) => {
-                let z = warp::reply();
-
                 let mut resp = e.to_string().into_response();
                 *resp.status_mut() = StatusCode::BAD_REQUEST;
                 Ok(resp)
@@ -470,7 +468,7 @@ pub mod service {
     pub(super) async fn revoke_version(
         domain_storage: Arc<DomainStorage>,
         query: DomainWithVersionOption,
-    ) -> Result<Response, Infallible> {
+    ) -> anyhow::Result<warp::reply::Response> {
         let DomainWithVersionOption { domain, version } = query;
         let resp = match domain_storage.get_domain_info_by_domain(&domain) {
             Some(info) => {
@@ -483,7 +481,7 @@ pub mod service {
                         .upload_domain_with_version(domain, Some(version))
                         .await
                     {
-                        Ok(_) => Response::default(),
+                        Ok(_) => warp::reply::Response::default(),
                         Err(e) => {
                             let mut resp = e.to_string().into_response();
                             *resp.status_mut() = StatusCode::BAD_REQUEST;

server/src/cors.rs

@@ -42,7 +42,7 @@ pub fn resp_cors_request<B:http_body::Body>(
     method: &Method,
     headers: &HeaderMap,
     origins: &Option<HashSet<HeaderValue>>,
-) -> Either<Validated, Response<B>> {
+) -> Either<Validated, warp::reply::Response> {
     match (headers.get(header::ORIGIN), method) {
         (Some(origin), &Method::OPTIONS) => {
             if !is_origin_allowed(origins, origin) {

server/src/service.rs

@@ -56,14 +56,13 @@ fn alias_redirect(uri: &Uri, https: bool, host: &str, external_port: u16) -> war
 }
 
 // static file reply
-#[instrument(skip(uri, host, domain_storage, origin_opt))]
-async fn file_resp<A:http_body::Body, B:http_body::Body>(
+async fn file_resp<A:http_body::Body>(
     req: &Request<A>,
     uri: &Uri,
     host: &str,
     domain_storage: Arc<DomainStorage>,
     origin_opt: Option<Validated>,
-) -> Result<Response<B>, Infallible> {
+) -> Result<warp::reply::Response, Infallible> {
     let path = uri.path();
     let mut resp = match get_cache_file(path, host, domain_storage.clone()).await {
         Some(item) => {
@@ -117,7 +116,6 @@ fn get_authority<B:http_body::Body>(req: &Request<B>) -> Option<Authority> {
     })
 }
 
-#[instrument(skip(service_config, domain_storage, challenge_path, external_port))]
 pub async fn create_http_service<B:http_body::Body>(
     req: Request<B>,
     service_config: Arc<ServiceConfig>,
@@ -180,7 +178,6 @@ pub async fn create_http_service<B:http_body::Body>(
     }
 }
 
-#[instrument(skip(service_config, domain_storage, external_port))]
 pub async fn create_https_service<B:http_body::Body>(
     req: Request<B>,
     service_config: Arc<ServiceConfig>,
@@ -214,19 +211,19 @@ pub async fn create_https_service<B:http_body::Body>(
     }
 }
 
-pub fn not_found<B:http_body::Body>() -> Response<B> {
+pub fn not_found<B:http_body::Body>() -> warp::reply::Response {
     let mut resp = Response::default();
     *resp.status_mut() = StatusCode::NOT_FOUND;
     resp
 }
-pub fn forbid<B:http_body::Body>() -> Response<B> {
+pub fn forbid() -> warp::reply::Response {
     let mut resp = Response::default();
     *resp.status_mut() = StatusCode::FORBIDDEN;
     resp
 }
 
 pub fn resp(code: StatusCode, str: &'static str) -> warp::reply::Response {
-    let mut response = str.into_response();
+    let mut resp = str.into_response();
     *resp.status_mut() = code;
     resp
 }

server/src/static_file_filter.rs

@@ -223,8 +223,8 @@ pub async fn cache_or_file_reply<A:http_body::Body>(
     }
 }
 
-fn cache_item_to_response_header<A:http_body::Body>(
-    resp: &mut Response<A>,
+fn cache_item_to_response_header(
+    resp: &mut Response<warp::reply::Response>,
     item: &CacheItem,
     modified: Option<LastModified>,
 ) {

server/src/tls.rs

@@ -162,6 +162,7 @@ pub(crate) fn load_ssl_file(
     Ok(CertifiedKey::new(certs, key))
 }
 
+
 /*
 enum State {
     Handshaking(tokio_rustls::Accept<AddrStream>),

server/src/web_server.rs

@@ -5,7 +5,7 @@ use futures_util::future::Either;
 use hyper_util::server::conn::auto::Builder;
 use hyper_util::rt::TokioIo;
 use hyper::service::service_fn;
-use rustls::ServerConfig;
+use tokio_rustls::rustls::ServerConfig;
 use socket2::{Domain, Socket, Type};
 use std::collections::HashMap;
 use std::convert::Infallible;
@@ -20,7 +20,7 @@ use crate::domain_storage::DomainStorage;
 use crate::service::{
     create_http_service, create_https_service, DomainServiceConfig, ServiceConfig,
 };
-use crate::tls::TlsAcceptor;
+//use crate::tls::TlsAcceptor;
 
 async fn handler(rx: Receiver<()>, time: DateTime<Local>, http_or_https: &'static str) {
     rx.await.ok();
@@ -251,7 +251,7 @@ impl Server {
             });
             let server = HServer::from_tcp(listener)?.serve(make_svc);
             run_server!(server, rx);
-            
+
              */
         }
         Ok(())