start from scratch
This commit is contained in:
Felipe Noronha
parent
2b2ef26523
commit
d45b2f71d0
@ -1,47 +0,0 @@
|
||||
//! A simple use of the `ReverseProxy` service.
|
||||
|
||||
extern crate futures;
|
||||
extern crate hyper;
|
||||
extern crate hyper_reverse_proxy;
|
||||
extern crate tokio_core;
|
||||
|
||||
use futures::Stream;
|
||||
use hyper::Client;
|
||||
use hyper::server::Http;
|
||||
use hyper_reverse_proxy::ReverseProxy;
|
||||
use tokio_core::net::TcpListener;
|
||||
use tokio_core::reactor::Core;
|
||||
use std::net::{SocketAddr, Ipv4Addr};
|
||||
|
||||
fn run() -> hyper::Result<()> {
|
||||
// Set up the Tokio reactor core
|
||||
let mut core = Core::new()?;
|
||||
let handle = core.handle();
|
||||
|
||||
// Set up a TCP socket to listen to
|
||||
let listen_addr = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
|
||||
let listener = TcpListener::bind(&listen_addr, &handle)?;
|
||||
|
||||
// Listen to incoming requests over TCP, and forward them to a new `ReverseProxy`
|
||||
let http = Http::new();
|
||||
let server = listener.incoming().for_each(|(socket, addr)| {
|
||||
let client = Client::new(&handle);
|
||||
let service = ReverseProxy::new(client, Some(addr.ip()));
|
||||
http.bind_connection(&handle, socket, addr, service);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
// Start our server on the reactor core
|
||||
core.run(server)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn main() {
|
||||
use std::io::{self, Write};
|
||||
|
||||
if let Err(error) = run() {
|
||||
write!(&mut io::stderr(), "{}", error).expect("Error writing to stderr");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
@ -1,151 +0,0 @@
|
||||
//! A more involved example of using the `ReverseProxy` service.
|
||||
|
||||
#[macro_use]
|
||||
extern crate error_chain;
|
||||
extern crate futures;
|
||||
extern crate hyper;
|
||||
extern crate hyper_reverse_proxy;
|
||||
extern crate tokio_core;
|
||||
extern crate tokio_signal;
|
||||
|
||||
use futures::{BoxFuture, Future, Stream};
|
||||
use tokio_core::reactor::Handle;
|
||||
use std::net::{SocketAddr, Ipv4Addr};
|
||||
|
||||
error_chain! {
|
||||
foreign_links {
|
||||
Io(std::io::Error);
|
||||
Hyper(hyper::Error);
|
||||
}
|
||||
}
|
||||
|
||||
fn shutdown_future(handle: &Handle) -> BoxFuture<(), std::io::Error> {
|
||||
use tokio_signal::unix::{Signal, SIGINT, SIGTERM};
|
||||
|
||||
let sigint = Signal::new(SIGINT, handle).flatten_stream();
|
||||
let sigterm = Signal::new(SIGTERM, handle).flatten_stream();
|
||||
|
||||
Stream::select(sigint, sigterm)
|
||||
.into_future()
|
||||
.map(|_| ())
|
||||
.map_err(|(e, _)| e)
|
||||
.boxed()
|
||||
}
|
||||
|
||||
fn run() -> Result<()> {
|
||||
use futures::task::{self, Task};
|
||||
use hyper::Client;
|
||||
use hyper::server::{Http, Service};
|
||||
use hyper_reverse_proxy::ReverseProxy;
|
||||
use std::rc::{Rc, Weak};
|
||||
use std::cell::RefCell;
|
||||
use std::time::Duration;
|
||||
use tokio_core::net::TcpListener;
|
||||
use tokio_core::reactor::{Core, Timeout};
|
||||
|
||||
struct Info {
|
||||
active: usize,
|
||||
blocker: Option<Task>,
|
||||
}
|
||||
|
||||
struct NotifyService<S> {
|
||||
inner: S,
|
||||
info: Weak<RefCell<Info>>,
|
||||
}
|
||||
|
||||
impl<S: Service> Service for NotifyService<S> {
|
||||
type Request = S::Request;
|
||||
type Response = S::Response;
|
||||
type Error = S::Error;
|
||||
type Future = S::Future;
|
||||
|
||||
fn call(&self, message: Self::Request) -> Self::Future {
|
||||
self.inner.call(message)
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> Drop for NotifyService<S> {
|
||||
fn drop(&mut self) {
|
||||
if let Some(info) = self.info.upgrade() {
|
||||
let mut info = info.borrow_mut();
|
||||
info.active -= 1;
|
||||
if info.active == 0 {
|
||||
if let Some(task) = info.blocker.take() {
|
||||
task.notify();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct WaitUntilZero {
|
||||
info: Rc<RefCell<Info>>,
|
||||
}
|
||||
|
||||
impl Future for WaitUntilZero {
|
||||
type Item = ();
|
||||
type Error = std::io::Error;
|
||||
|
||||
fn poll(&mut self) -> futures::Poll<(), std::io::Error> {
|
||||
use futures::Async;
|
||||
|
||||
let mut info = self.info.borrow_mut();
|
||||
if info.active == 0 {
|
||||
Ok(Async::Ready(()))
|
||||
} else {
|
||||
info.blocker = Some(task::current());
|
||||
Ok(Async::NotReady)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Set up the Tokio reactor core
|
||||
let mut core = Core::new()?;
|
||||
let handle = core.handle();
|
||||
|
||||
// Set up a TCP socket to listen to
|
||||
let listen_addr = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
|
||||
let listener = TcpListener::bind(&listen_addr, &handle)?;
|
||||
|
||||
println!("Listening on {}", listen_addr);
|
||||
|
||||
// Keep track of how many active connections we are managing
|
||||
let info = Rc::new(RefCell::new(Info {
|
||||
active: 0,
|
||||
blocker: None,
|
||||
}));
|
||||
|
||||
// Listen to incoming requests over TCP, and forward them to a new `ReverseProxy`
|
||||
let http = Http::new();
|
||||
let server = listener.incoming().for_each(|(socket, addr)| {
|
||||
let client = Client::new(&handle);
|
||||
let service = NotifyService {
|
||||
inner: ReverseProxy::new(client, Some(addr.ip())),
|
||||
info: Rc::downgrade(&info),
|
||||
};
|
||||
|
||||
info.borrow_mut().active += 1;
|
||||
http.bind_connection(&handle, socket, addr, service);
|
||||
Ok(())
|
||||
});
|
||||
|
||||
let shutdown = shutdown_future(&handle);
|
||||
|
||||
// Start our server, blocking the main thread.
|
||||
match core.run(Future::select(shutdown, server)) {
|
||||
Ok(((), _next)) => {}
|
||||
Err((error, _next)) => bail!(error),
|
||||
}
|
||||
|
||||
println!("Shutting down gracefully");
|
||||
|
||||
// Let the outstanding requests run for 2 seconds, then shut down the server
|
||||
let timeout = Timeout::new(Duration::from_secs(2), &handle)?;
|
||||
let wait = WaitUntilZero { info: info.clone() };
|
||||
match core.run(Future::select(wait, timeout)) {
|
||||
Ok(((), _next)) => Ok(()),
|
||||
Err((error, _next)) => Err(error.into()),
|
||||
}
|
||||
}
|
||||
|
||||
quick_main!(run);
|
||||
241
src/lib.rs
241
src/lib.rs
@ -1,241 +0,0 @@
|
||||
//! A simple reverse proxy, to be used with [Hyper] and [Tokio].
|
||||
//!
|
||||
//! The implementation ensures that [Hop-by-hop headers] are stripped correctly in both directions,
|
||||
//! and adds the client's IP address to a comma-space-separated list of forwarding addresses in the
|
||||
//! `X-Forwarded-For` header.
|
||||
//!
|
||||
//! The implementation is based on Go's [`httputil.ReverseProxy`].
|
||||
//!
|
||||
//! [Hyper]: http://hyper.rs/
|
||||
//! [Tokio]: http://tokio.rs/
|
||||
//! [Hop-by-hop headers]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
|
||||
//! [`httputil.ReverseProxy`]: https://golang.org/pkg/net/http/httputil/#ReverseProxy
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! Because the reverse proxy needs client, we also need a [`Handle`]. This
|
||||
//! means that we can't take advantage of hyper's handy [`Http::bind`] method
|
||||
//! to quickly set up the server. Instead we do things manually:
|
||||
//!
|
||||
//! [`Handle`]: https://docs.rs/tokio-core/*/tokio_core/reactor/struct.Handle.html
|
||||
//! [`Http::bind`]: https://docs.rs/hyper/*/hyper/server/struct.Http.html#method.bind
|
||||
//!
|
||||
//! ```rust,no_run
|
||||
//! extern crate futures;
|
||||
//! extern crate hyper;
|
||||
//! extern crate hyper_reverse_proxy;
|
||||
//! extern crate tokio_core;
|
||||
//!
|
||||
//! use futures::Stream;
|
||||
//! use hyper::Client;
|
||||
//! use hyper::server::Http;
|
||||
//! use hyper_reverse_proxy::ReverseProxy;
|
||||
//! use tokio_core::net::TcpListener;
|
||||
//! use tokio_core::reactor::Core;
|
||||
//! use std::net::{SocketAddr, Ipv4Addr};
|
||||
//!
|
||||
//! fn run() -> hyper::Result<()> {
|
||||
//! // Set up the Tokio reactor core
|
||||
//! let mut core = Core::new()?;
|
||||
//! let handle = core.handle();
|
||||
//!
|
||||
//! // Set up a TCP socket to listen to
|
||||
//! let listen_addr = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
|
||||
//! let listener = TcpListener::bind(&listen_addr, &handle)?;
|
||||
//!
|
||||
//! // Listen to incoming requests over TCP, and forward them to a new `ReverseProxy`
|
||||
//! let http = Http::new();
|
||||
//! let server = listener.incoming().for_each(|(socket, addr)| {
|
||||
//! let client = Client::new(&handle);
|
||||
//! let service = ReverseProxy::new(client, Some(addr.ip()));
|
||||
//! http.bind_connection(&handle, socket, addr, service);
|
||||
//! Ok(())
|
||||
//! });
|
||||
//!
|
||||
//! // Start our server on the reactor core
|
||||
//! core.run(server)?;
|
||||
//!
|
||||
//! Ok(())
|
||||
//! }
|
||||
//!
|
||||
//! fn main() {
|
||||
//! use std::io::{self, Write};
|
||||
//!
|
||||
//! if let Err(error) = run() {
|
||||
//! write!(&mut io::stderr(), "{}", error).expect("Error writing to stderr");
|
||||
//! std::process::exit(1);
|
||||
//! }
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! Note that in a production system we might also want to:
|
||||
//!
|
||||
//! - listen for `SIGINT` and `SIGTERM` signals using [tokio_signal]
|
||||
//! - shut down the server gracefully, waiting for outstanding requests to complete
|
||||
//!
|
||||
//! To see an example of this, look at [examples/extended.rs].
|
||||
//!
|
||||
//! [examples/extended.rs]: https://github.com/brendanzab/hyper-reverse-proxy/blob/master/examples/extended.rs
|
||||
//! [tokio_signal]: https://github.com/alexcrichton/tokio-signal
|
||||
|
||||
extern crate futures;
|
||||
#[macro_use]
|
||||
extern crate hyper;
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
extern crate unicase;
|
||||
|
||||
use futures::future::Future;
|
||||
use hyper::{Body, Headers, Request, Response, StatusCode};
|
||||
use hyper::server::Service;
|
||||
use std::marker::PhantomData;
|
||||
use std::net::IpAddr;
|
||||
|
||||
fn is_hop_header(name: &str) -> bool {
|
||||
use unicase::Ascii;
|
||||
|
||||
// A list of the headers, using `unicase` to help us compare without
|
||||
// worrying about the case, and `lazy_static!` to prevent reallocation
|
||||
// of the vector.
|
||||
lazy_static! {
|
||||
static ref HOP_HEADERS: Vec<Ascii<&'static str>> = vec![
|
||||
Ascii::new("Connection"),
|
||||
Ascii::new("Keep-Alive"),
|
||||
Ascii::new("Proxy-Authenticate"),
|
||||
Ascii::new("Proxy-Authorization"),
|
||||
Ascii::new("Te"),
|
||||
Ascii::new("Trailers"),
|
||||
Ascii::new("Transfer-Encoding"),
|
||||
Ascii::new("Upgrade"),
|
||||
];
|
||||
}
|
||||
|
||||
HOP_HEADERS.iter().any(|h| h == &name)
|
||||
}
|
||||
|
||||
/// Returns a clone of the headers without the [hop-by-hop headers].
|
||||
///
|
||||
/// [hop-by-hop headers]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
|
||||
fn remove_hop_headers(headers: &Headers) -> Headers {
|
||||
headers
|
||||
.iter()
|
||||
.filter(|header| !is_hop_header(header.name()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
// TODO: use https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded ?
|
||||
header! {
|
||||
/// `X-Forwarded-For` header.
|
||||
///
|
||||
/// The `X-Forwarded-For` header describes the path of
|
||||
/// proxies this request has been forwarded through.
|
||||
///
|
||||
/// # Example Values
|
||||
///
|
||||
/// * `2001:db8:85a3:8d3:1319:8a2e:370:7348`
|
||||
/// * `203.0.113.195`
|
||||
/// * `203.0.113.195, 70.41.3.18, 150.172.238.178`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # extern crate hyper;
|
||||
/// # extern crate hyper_reverse_proxy;
|
||||
/// use hyper::Headers;
|
||||
/// use hyper_reverse_proxy::XForwardedFor;
|
||||
/// use std::net::{Ipv4Addr, Ipv6Addr};
|
||||
///
|
||||
/// # fn main() {
|
||||
/// let mut headers = Headers::new();
|
||||
/// headers.set(XForwardedFor(vec![
|
||||
/// Ipv4Addr::new(127, 0, 0, 1).into(),
|
||||
/// Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into(),
|
||||
/// ]));
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// # References
|
||||
///
|
||||
/// - [MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For)
|
||||
/// - [Wikipedia](https://en.wikipedia.org/wiki/X-Forwarded-For)
|
||||
(XForwardedFor, "X-Forwarded-For") => (IpAddr)+
|
||||
|
||||
// test_x_forwarded_for {
|
||||
// // Testcases from MDN
|
||||
// test_header!(test1, vec![b"2001:db8:85a3:8d3:1319:8a2e:370:7348"]);
|
||||
// test_header!(test2, vec![b"203.0.113.195"]);
|
||||
// test_header!(test3, vec![b"203.0.113.195, 70.41.3.18, 150.172.238.178"]);
|
||||
// }
|
||||
}
|
||||
|
||||
fn create_proxied_response<B>(mut response: Response<B>) -> Response<B> {
|
||||
*response.headers_mut() = remove_hop_headers(response.headers());
|
||||
response
|
||||
}
|
||||
|
||||
/// A `Service` that takes an incoming request, sends it to a given `Client`, then proxies back
|
||||
/// the response.
|
||||
pub struct ReverseProxy<C: Service, B = Body> {
|
||||
client: C,
|
||||
remote_ip: Option<IpAddr>,
|
||||
_pantom_data: PhantomData<B>,
|
||||
}
|
||||
|
||||
impl<C: Service, B> ReverseProxy<C, B> {
|
||||
/// Construct a reverse proxy that dispatches to the given client.
|
||||
pub fn new(client: C, remote_ip: Option<IpAddr>) -> ReverseProxy<C, B> {
|
||||
ReverseProxy {
|
||||
client,
|
||||
remote_ip,
|
||||
_pantom_data: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
fn create_proxied_request(&self, mut request: Request<B>) -> Request<B> {
|
||||
*request.headers_mut() = remove_hop_headers(request.headers());
|
||||
|
||||
// Add forwarding information in the headers
|
||||
if let Some(ip) = self.remote_ip {
|
||||
// This is kind of ugly because of borrowing. Maybe hyper's `Headers` object
|
||||
// could use an entry API like `std::collections::HashMap`?
|
||||
if request.headers().has::<XForwardedFor>() {
|
||||
if let Some(prior) = request.headers_mut().get_mut::<XForwardedFor>() {
|
||||
prior.push(ip);
|
||||
}
|
||||
} else {
|
||||
let header = XForwardedFor(vec![ip]);
|
||||
request.headers_mut().set(header);
|
||||
}
|
||||
}
|
||||
|
||||
request
|
||||
}
|
||||
}
|
||||
|
||||
impl<C, B> Service for ReverseProxy<C, B>
|
||||
where
|
||||
B: 'static,
|
||||
C: Service<Request = Request<B>, Response = Response<B>>,
|
||||
C::Error: 'static + std::fmt::Display,
|
||||
C::Future: 'static,
|
||||
{
|
||||
type Request = Request<B>;
|
||||
type Response = Response<B>;
|
||||
type Error = hyper::Error;
|
||||
type Future = Box<Future<Item = Response<B>, Error = hyper::Error>>;
|
||||
|
||||
fn call(&self, request: Self::Request) -> Self::Future {
|
||||
let proxied_request = self.create_proxied_request(request);
|
||||
|
||||
Box::new(self.client.call(proxied_request).then(|response| {
|
||||
Ok(match response {
|
||||
Ok(response) => create_proxied_response(response),
|
||||
Err(error) => {
|
||||
println!("Error: {}", error); // TODO: Configurable logging
|
||||
Response::new().with_status(StatusCode::InternalServerError)
|
||||
// TODO: handle trailers
|
||||
}
|
||||
})
|
||||
}))
|
||||
}
|
||||
}
|
||||
178
tests/lib.rs
178
tests/lib.rs
@ -1,178 +0,0 @@
|
||||
extern crate futures;
|
||||
#[macro_use]
|
||||
extern crate hyper;
|
||||
extern crate hyper_reverse_proxy;
|
||||
|
||||
use futures::future::{self, Future, FutureResult};
|
||||
use hyper::{Get, Request, Response};
|
||||
use hyper::server::Service;
|
||||
use hyper_reverse_proxy::ReverseProxy;
|
||||
|
||||
struct MockService<F: Fn(Request) -> Response>(F);
|
||||
|
||||
impl<F: Fn(Request) -> Response> Service for MockService<F> {
|
||||
type Request = Request;
|
||||
type Response = Response;
|
||||
type Error = hyper::Error;
|
||||
type Future = FutureResult<Response, hyper::Error>;
|
||||
|
||||
fn call(&self, request: Self::Request) -> Self::Future {
|
||||
future::ok((self.0)(request))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn begins_forwarded_for_header() {
|
||||
use hyper_reverse_proxy::XForwardedFor;
|
||||
use std::net::Ipv6Addr;
|
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap());
|
||||
request.set_body("request");
|
||||
|
||||
let remote_ip = Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let client = MockService(|request| {
|
||||
assert_eq!(
|
||||
request.headers().get::<XForwardedFor>(),
|
||||
Some(&XForwardedFor(
|
||||
vec![Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8).into()],
|
||||
))
|
||||
);
|
||||
|
||||
Response::new()
|
||||
});
|
||||
let service = ReverseProxy::new(client, Some(remote_ip.into()));
|
||||
|
||||
service.call(request).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn continues_forwarded_for_header() {
|
||||
use hyper_reverse_proxy::XForwardedFor;
|
||||
use std::net::{Ipv4Addr, Ipv6Addr};
|
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap());
|
||||
request.set_body("request");
|
||||
request.headers_mut().set(XForwardedFor(vec![
|
||||
Ipv4Addr::new(127, 0, 0, 1).into(),
|
||||
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into(),
|
||||
]));
|
||||
|
||||
let remote_ip = Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let client = MockService(|request| {
|
||||
assert_eq!(
|
||||
request.headers().get::<XForwardedFor>(),
|
||||
Some(&XForwardedFor(vec![
|
||||
Ipv4Addr::new(127, 0, 0, 1).into(),
|
||||
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into(),
|
||||
Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8).into(),
|
||||
]))
|
||||
);
|
||||
|
||||
Response::new()
|
||||
});
|
||||
let service = ReverseProxy::new(client, Some(remote_ip.into()));
|
||||
|
||||
service.call(request).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forwards_the_bodies() {
|
||||
use futures::Stream;
|
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap());
|
||||
request.set_body("request");
|
||||
|
||||
let client = MockService(|request| {
|
||||
let body = request.body().concat2().wait().unwrap();
|
||||
assert_eq!(body.as_ref(), b"request");
|
||||
|
||||
Response::new().with_body("response")
|
||||
});
|
||||
let service = ReverseProxy::new(client, None);
|
||||
|
||||
let response = service.call(request).wait().unwrap();
|
||||
let body = response.body().concat2().wait().unwrap();
|
||||
assert_eq!(body.as_ref(), b"response");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clones_headers() {
|
||||
header! { (XTestHeader1, "X-Test-Header1") => [String] }
|
||||
header! { (XTestHeader2, "X-Test-Header2") => [String] }
|
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap());
|
||||
request.headers_mut().set(XTestHeader1("Test1".to_owned()));
|
||||
request.headers_mut().set(XTestHeader2("Test2".to_owned()));
|
||||
|
||||
let client = MockService(|request| {
|
||||
let header1 = request.headers().get::<XTestHeader1>().unwrap();
|
||||
let header2 = request.headers().get::<XTestHeader2>().unwrap();
|
||||
assert_eq!(header1, &XTestHeader1("Test1".to_owned()));
|
||||
assert_eq!(header2, &XTestHeader2("Test2".to_owned()));
|
||||
Response::new()
|
||||
});
|
||||
let service = ReverseProxy::new(client, None);
|
||||
|
||||
service.call(request).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removes_request_hop_headers() {
|
||||
use hyper::header::{Connection, TransferEncoding, Upgrade};
|
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap());
|
||||
request.headers_mut().set(Connection(vec![]));
|
||||
request.headers_mut().set_raw("Keep-Alive", "");
|
||||
request.headers_mut().set_raw("Proxy-Authenticate", "");
|
||||
request.headers_mut().set_raw("Proxy-Authorization", "");
|
||||
request.headers_mut().set_raw("TE", "");
|
||||
request.headers_mut().set_raw("Trailers", "");
|
||||
request.headers_mut().set(TransferEncoding(vec![]));
|
||||
request.headers_mut().set(Upgrade(vec![]));
|
||||
|
||||
let client = MockService(|request| {
|
||||
assert_eq!(request.headers().get::<Connection>(), None);
|
||||
assert_eq!(request.headers().get_raw("Keep-Alive"), None);
|
||||
assert_eq!(request.headers().get_raw("Proxy-Authenticate"), None);
|
||||
assert_eq!(request.headers().get_raw("Proxy-Authorization"), None);
|
||||
assert_eq!(request.headers().get_raw("TE"), None);
|
||||
assert_eq!(request.headers().get_raw("Trailers"), None);
|
||||
assert_eq!(request.headers().get::<TransferEncoding>(), None);
|
||||
assert_eq!(request.headers().get::<Upgrade>(), None);
|
||||
Response::new()
|
||||
});
|
||||
let service = ReverseProxy::new(client, None);
|
||||
|
||||
service.call(request).wait().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removes_response_hop_headers() {
|
||||
use hyper::header::{Connection, TransferEncoding, Upgrade};
|
||||
|
||||
let request = Request::new(Get, "/".parse().unwrap());
|
||||
|
||||
let client = MockService(|_| {
|
||||
let mut response = Response::new();
|
||||
response.headers_mut().set(Connection(vec![]));
|
||||
response.headers_mut().set_raw("Keep-Alive", "");
|
||||
response.headers_mut().set_raw("Proxy-Authenticate", "");
|
||||
response.headers_mut().set_raw("Proxy-Authorization", "");
|
||||
response.headers_mut().set_raw("TE", "");
|
||||
response.headers_mut().set_raw("Trailers", "");
|
||||
response.headers_mut().set(TransferEncoding(vec![]));
|
||||
response.headers_mut().set(Upgrade(vec![]));
|
||||
response
|
||||
});
|
||||
let service = ReverseProxy::new(client, None);
|
||||
|
||||
let response = service.call(request).wait().unwrap();
|
||||
assert_eq!(response.headers().get::<Connection>(), None);
|
||||
assert_eq!(response.headers().get_raw("Keep-Alive"), None);
|
||||
assert_eq!(response.headers().get_raw("Proxy-Authenticate"), None);
|
||||
assert_eq!(response.headers().get_raw("Proxy-Authorization"), None);
|
||||
assert_eq!(response.headers().get_raw("TE"), None);
|
||||
assert_eq!(response.headers().get_raw("Trailers"), None);
|
||||
assert_eq!(response.headers().get::<TransferEncoding>(), None);
|
||||
assert_eq!(response.headers().get::<Upgrade>(), None);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user