use std::fmt;
use super::TunnelProvider;
use crate::error::Result;
use crate::net::tunnel;
pub struct Tunnel {
inner: Box<dyn tunnel::Tunnel>,
provider: TunnelProvider,
}
impl fmt::Debug for Tunnel {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Tunnel")
.field("host", &self.host())
.field("provider", &self.provider)
.finish()
}
}
impl Tunnel {
pub fn start(port: u16, provider: TunnelProvider) -> Result<Tunnel> {
Tunnel::start_with_stop(port, provider, &|| false)
}
pub fn start_with_stop(
port: u16,
provider: TunnelProvider,
stop: &dyn Fn() -> bool,
) -> Result<Tunnel> {
let inner = tunnel::start(port, provider, stop)?;
Ok(Tunnel { inner, provider })
}
pub fn start_auto(port: u16, stop: &dyn Fn() -> bool) -> Result<Tunnel> {
match Tunnel::start_with_stop(port, TunnelProvider::Cloudflare, stop) {
Ok(t) => Ok(t),
Err(e) if stop() => Err(e),
Err(e) => {
warn!(
"tunnel: Cloudflare failed ({}); trying OpenTunnel",
e.message()
);
Tunnel::start_with_stop(port, TunnelProvider::OpenTunnel, stop)
}
}
}
pub fn host(&self) -> &str {
self.inner.host()
}
pub fn url(&self) -> String {
format!("https://{}/", self.inner.host())
}
pub fn provider(&self) -> TunnelProvider {
self.provider
}
pub fn provider_name(&self) -> &'static str {
self.inner.name()
}
pub fn visitor(&self, local_peer: std::net::SocketAddr) -> Option<String> {
self.inner.peer_lookup().and_then(|f| f(local_peer))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct QrCode(crate::util::qr::Qr);
impl QrCode {
pub fn encode(text: &str) -> Option<QrCode> {
crate::util::qr::encode(text.as_bytes(), crate::util::qr::MAX_VERSION).map(QrCode)
}
pub fn version(&self) -> u8 {
self.0.version
}
pub fn size(&self) -> usize {
self.0.size
}
pub fn dark(&self, x: usize, y: usize) -> bool {
self.0.dark(x, y)
}
pub fn rows(&self) -> Vec<String> {
self.0.rows()
}
pub fn to_svg(&self, quiet: usize) -> String {
self.0.to_svg(quiet)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn qr_code() {
let qr =
QrCode::encode("https://example.trycloudflare.com/?r=BCDF#k=0123456789abcdefghijkl")
.unwrap();
assert_eq!(qr.size(), 4 * qr.version() as usize + 17);
let rows = qr.rows();
assert_eq!(rows.len(), qr.size());
assert!(rows.iter().all(|r| r.len() == qr.size()));
assert!(qr.dark(0, 0) && qr.dark(qr.size() - 1, 0) && qr.dark(0, qr.size() - 1));
assert!(!qr.dark(qr.size(), 0));
assert!(qr.to_svg(4).starts_with("<svg"));
assert!(QrCode::encode(&"x".repeat(4000)).is_none());
}
#[test]
#[cfg(not(feature = "tunnel"))]
fn tunnel_needs_the_feature() {
assert!(Tunnel::start(1, TunnelProvider::Cloudflare).is_err());
}
}