tuxmain/rust-rpxy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

some refactor

Browse source
This commit is contained in:
Jun Kurihara 2022-07-09 19:40:48 +09:00
commit ebb2fb3c87
No known key found for this signature in database
GPG key ID: 48ADFD173ED22B03
3 changed files with 44 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

27
src/proxy/proxy_handler.rs
View file

@ -19,19 +19,14 @@ where
mut req: Request<Body>,
client_addr: SocketAddr, // アクセス制御用
) -> Result<Response<Body>> {
let request_log = log_request_msg(&req, &client_addr);
req.log(&client_addr, Some("(Incoming)"));
// Here we start to handle with server_name
// Find backend application for given server_name
let (server_name, _port) = if let Ok(v) = parse_host_port(&req) {
v
} else {
info!("{} => {}", request_log, StatusCode::BAD_REQUEST);
return http_error(StatusCode::BAD_REQUEST);
};
// Find backend application for given server_name, and drop if incoming request is invalid as request.
let (server_name, _port) = parse_host_port(&req)?;
if !self.backends.apps.contains_key(&server_name) && self.backends.default_app.is_none() {
info!("{} => {}", request_log, StatusCode::SERVICE_UNAVAILABLE);
// info!("{} => {}", request_log, StatusCode::SERVICE_UNAVAILABLE);
return http_error(StatusCode::SERVICE_UNAVAILABLE);
}
let backend = if let Some(be) = self.backends.apps.get(&server_name) {
@ -45,7 +40,7 @@ where
// Redirect to https if !tls_enabled and redirect_to_https is true
if !self.tls_enabled && backend.https_redirection.unwrap_or(false) {
debug!("Redirect to secure connection: {}", server_name);
info!("{} => {}", request_log, StatusCode::PERMANENT_REDIRECT);
// info!("{} => {}", request_log, StatusCode::PERMANENT_REDIRECT);
return secure_redirection(&server_name, self.globals.https_port, &req);
}
@ -108,7 +103,7 @@ where
}
}
debug!("Response from backend: {:?}", res_backend.status());
let response_log = res_backend.status().to_string();
// let response_log = res_backend.status().to_string();
if res_backend.status() == StatusCode::SWITCHING_PROTOCOLS {
// Handle StatusCode::SWITCHING_PROTOCOLS in response
@ -138,11 +133,11 @@ where
.map_err(|e| anyhow!("Coping between upgraded connections failed: {}", e))?; // TODO: any response code?
Ok(()) as Result<()>
});
info!("{} => {}", request_log, response_log);
// info!("{} => {}", request_log, response_log);
Ok(res_backend)
} else {
error!("Request does not have an upgrade extension");
info!("{} => {}", request_log, StatusCode::BAD_REQUEST);
// info!("{} => {}", request_log, StatusCode::BAD_REQUEST);
http_error(StatusCode::BAD_REQUEST)
}
} else {
@ -150,16 +145,16 @@ where
"Backend tried to switch to protocol {:?} when {:?} was requested",
upgrade_in_response, upgrade_in_request
);
info!("{} => {}", request_log, StatusCode::SERVICE_UNAVAILABLE);
// info!("{} => {}", request_log, StatusCode::SERVICE_UNAVAILABLE);
http_error(StatusCode::SERVICE_UNAVAILABLE)
}
} else {
// Generate response to client
if self.generate_response_forwarded(&mut res_backend).is_ok() {
info!("{} => {}", request_log, response_log);
// info!("{} => {}", request_log, response_log);
Ok(res_backend)
} else {
info!("{} => {}", request_log, StatusCode::BAD_GATEWAY);
// info!("{} => {}", request_log, StatusCode::BAD_GATEWAY);
http_error(StatusCode::BAD_GATEWAY)
}
}

10
src/proxy/utils_headers.rs
View file

@ -1,7 +1,7 @@
use super::{Upstream, UpstreamOption};
use crate::{error::*, log::*, utils::*};
use hyper::{
header::{self, HeaderMap, HeaderValue},
header::{self, HeaderMap, HeaderName, HeaderValue},
Uri,
};
use std::net::SocketAddr;
@ -29,12 +29,8 @@ pub(super) fn apply_upstream_options_to_header(
Ok(())
}
pub(super) fn append_header_entry(
headers: &mut HeaderMap,
key: &'static str,
value: &str,
) -> Result<()> {
match headers.entry(key) {
pub(super) fn append_header_entry(headers: &mut HeaderMap, key: &str, value: &str) -> Result<()> {
match headers.entry(HeaderName::from_bytes(key.as_bytes())?) {
header::Entry::Vacant(entry) => {
entry.insert(value.parse::<HeaderValue>()?);
}

32
src/proxy/utils_request.rs
View file

@ -1,34 +1,40 @@
use crate::{error::*, utils::*};
use crate::{error::*, log::*, utils::*};
use hyper::{header, Request, Uri};
use std::net::SocketAddr;
use std::fmt::Display;
////////////////////////////////////////////////////
// Functions of utils for request messages
pub trait MsgLog {
fn log<T: Display + ToCanonical>(self, src: &T, extra: Option<&str>);
}
impl<B> MsgLog for &Request<B> {
fn log<T: Display + ToCanonical>(self, src: &T, extra: Option<&str>) {
let canonical_src = src.to_canonical();
pub(super) fn log_request_msg<B>(req: &Request<B>, client_addr: &SocketAddr) -> String {
let server_name = req.headers().get(header::HOST).map_or_else(
let server_name = self.headers().get(header::HOST).map_or_else(
|| {
req
self
.uri()
.authority()
.map_or_else(|| "<none>", |au| au.as_str())
},
|h| h.to_str().unwrap_or("<none>"),
);
return format!(
"{} <- {} -- {} {:?} {:?} ({:?})",
info!(
"{} <- {} -- {} {:?} {:?} {:?} {}",
server_name,
client_addr.to_canonical(),
req.method(),
req.version(),
req
canonical_src,
self.method(),
self.version(),
self
.uri()
.path_and_query()
.map_or_else(|| "", |v| v.as_str()),
req.headers()
self.headers(),
extra.map_or_else(|| "", |v| v)
);
}
}
pub(super) fn parse_host_port<B: core::fmt::Debug>(
req: &Request<B>,