camo-rs 0.1.1

Camo proxies insecure HTTP images over HTTPS, preventing mixed content warnings on secure pages.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use crate::server::{
    config::Config,
    error::CamoError,
    http_client::WorkerFetchClient,
    router::{create_router, AppState},
};
use std::sync::Arc;
use tower_service::Service;
use worker::{event, Context, Env, HttpRequest, Result};

#[event(fetch)]
pub async fn fetch(
    req: HttpRequest,
    env: Env,
    _ctx: Context,
) -> Result<axum::http::Response<axum::body::Body>> {
    console_error_panic_hook::set_once();
    Ok(create_router(Arc::new(AppState::from_worker_env(&env)?))
        .call(req)
        .await?)
}

impl Config {
    pub fn from_worker_env(env: &worker::Env) -> Result<Self, CamoError> {
        let key = env.secret("CAMO_KEY").map(|s| s.to_string()).ok();

        if key.is_none() || key.as_ref().map(|s| s.is_empty()).unwrap_or(true) {
            return Err(CamoError::InvalidUrl("CAMO_KEY not set".into()));
        }

        let max_size = env
            .var("CAMO_MAX_SIZE")
            .map(|v| v.to_string().parse().unwrap_or(5 * 1024 * 1024))
            .unwrap_or(5 * 1024 * 1024);

        Ok(Config {
            key,
            listen: "0.0.0.0:8080".to_string(),
            max_size,
            max_redirects: 4,
            timeout: 10,
            allow_video: false,
            allow_audio: false,
            block_private: true,
            metrics: false,
            log_level: "info".to_string(),
        })
    }
}

impl AppState {
    pub fn from_worker_env(env: &worker::Env) -> Result<Self, CamoError> {
        let config = Config::from_worker_env(env)?;
        Ok(AppState::from_config(&config))
    }
}

impl From<CamoError> for worker::Error {
    fn from(err: CamoError) -> Self {
        worker::Error::RustError(err.to_string())
    }
}