Struct trillium_proxy::Proxy
source · [−]pub struct Proxy<C: Connector> { /* private fields */ }
Expand description
the proxy handler
Implementations
sourceimpl<C: Connector> Proxy<C>
impl<C: Connector> Proxy<C>
sourcepub fn new(target: impl TryInto<Url>) -> Self
pub fn new(target: impl TryInto<Url>) -> Self
construct a new proxy handler that sends all requests to the url provided. if the url contains a path, the inbound request path will be joined onto the end.
use trillium_smol::{TcpConnector, ClientConfig};
use trillium_proxy::Proxy;
let proxy = Proxy::<TcpConnector>::new("http://docs.trillium.rs/trillium_proxy");
sourcepub fn with_config(self, config: C::Config) -> Self
pub fn with_config(self, config: C::Config) -> Self
chainable constructor to specify the client Connector configuration
use trillium_smol::{TcpConnector, ClientConfig};
use trillium_proxy::Proxy;
let proxy = Proxy::<TcpConnector>::new("http://trillium.rs")
.with_config(ClientConfig { //<-
nodelay: Some(true),
..Default::default()
});
sourcepub fn with_client(self, client: Client<C>) -> Self
pub fn with_client(self, client: Client<C>) -> Self
chainable constructor to specfiy a Client
to use. This is
useful if the application already is using trillium_client for
other requests, as it will reuse the same connection pool and
connector config.
note that this clears out any changes made with
Proxy::with_config
. configure the client directly if you are
providing one
use trillium_smol::{TcpConnector, ClientConfig};
use trillium_proxy::{Proxy, Client};
let client = Client::new().with_default_pool();
let proxy = Proxy::<TcpConnector>::new("http://trillium.rs")
.with_client(client); //<-
// sharing a client with other trillium handlers
use trillium::State;
let client = Client::new().with_default_pool();
let handler = (
State::new(client.clone()),
Proxy::<TcpConnector>::new("http://trillium.rs").with_client(client)
);
sourcepub fn proxy_not_found(self) -> Self
pub fn proxy_not_found(self) -> Self
chainable constructor to set the 404 Not Found handling
behavior. By default, this proxy will pass through the trillium
Conn unmodified if the proxy response is a 404 not found, allowing
it to be chained in a tuple handler. To modify this behavior, call
proxy_not_found, and the full 404 response will be forwarded. The
Conn will be halted unless Proxy::without_halting
was
configured
let proxy = Proxy::<TcpConnector>::new("http://trillium.rs")
.proxy_not_found();
sourcepub fn without_halting(self) -> Self
pub fn without_halting(self) -> Self
The default behavior for this handler is to halt the conn on any
response other than a 404. If Proxy::proxy_not_found
has been
configured, the default behavior for all response statuses is to
halt the trillium conn. To change this behavior, call
without_halting when constructing the proxy, and it will not halt
the conn. This is useful when passing the proxy reply through
trillium_html_rewriter
.
let proxy = Proxy::<TcpConnector>::new("http://trillium.rs")
.without_halting();
Trait Implementations
sourceimpl<C: Connector> Handler for Proxy<C>
impl<C: Connector> Handler for Proxy<C>
sourcefn run<'life0, 'async_trait>(
&'life0 self,
conn: Conn
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn run<'life0, 'async_trait>(
&'life0 self,
conn: Conn
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
sourcefn has_upgrade(&self, upgrade: &Upgrade<BoxedTransport>) -> bool
fn has_upgrade(&self, upgrade: &Upgrade<BoxedTransport>) -> bool
Handler::upgrade
]. The first
handler that responds true to this will receive ownership of the
[trillium::Upgrade
][crate::Upgrade] in a subsequent call to [Handler::upgrade
] Read moresourcefn upgrade<'life0, 'async_trait>(
&'life0 self,
upgrade: Upgrade
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn upgrade<'life0, 'async_trait>(
&'life0 self,
upgrade: Upgrade
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
Handler::has_upgrade
] and will only be called once for this
upgrade. There is no return value, and this function takes
exclusive ownership of the underlying transport once this is
called. You can downcast the transport to whatever the source
transport type is and perform any non-http protocol communication
that has been negotiated. You probably don’t want this unless
you’re implementing something like websockets. Please note that
for many transports such as TcpStreams, dropping the transport
(and therefore the Upgrade) will hang up / disconnect. Read more