snops 0.1.0

The snarkops control plane responsible for managing environments and agents
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::str::FromStr;

use axum::{
    extract::{Path, Request, State},
    middleware,
    response::{IntoResponse, Redirect, Response},
    routing::get,
    Router,
};
use http::{StatusCode, Uri};
use snops_common::{
    binaries::{BinaryEntry, BinarySource},
    state::{InternedId, NetworkId, StorageId},
};
use tower::Service;
use tower_http::services::ServeFile;

use super::AppState;
use crate::{
    schema::{
        error::StorageError,
        storage::{DEFAULT_AGENT_BINARY, DEFAULT_AOT_BINARY},
    },
    server::error::ServerError,
    state::GlobalState,
    unwrap_or_not_found,
};

async fn not_found(uri: Uri, res: Response) -> Response {
    match res.status() {
        StatusCode::NOT_FOUND => {
            let path = uri.path();
            let content = path.split('/').last().unwrap();
            ServerError::ContentNotFound(content.to_owned()).into_response()
        }
        _ => res,
    }
}

pub(super) async fn init_routes(state: &GlobalState) -> Router<AppState> {
    // create storage path
    let storage_path = state.cli.path.join("storage");
    tracing::debug!("storage path: {:?}", storage_path);
    tokio::fs::create_dir_all(&storage_path)
        .await
        .expect("failed to create ledger storage path");

    Router::new()
        // the snarkOS binary
        .route_service(
            "/snarkos",
            get(|req: Request| respond_from_entry(InternedId::default(), &DEFAULT_AOT_BINARY, req))
                .head(|req: Request| {
                    respond_from_entry(InternedId::default(), &DEFAULT_AOT_BINARY, req)
                }),
        )
        // the agent binary
        .route_service(
            "/agent",
            get(|req: Request| {
                respond_from_entry(
                    InternedId::from_str("agent").unwrap(),
                    &DEFAULT_AGENT_BINARY,
                    req,
                )
            }),
        )
        // ledger/block storage derived from tests (.tar.gz'd)
        .route("/storage/:network/:storage_id/:file", get(serve_file))
        .route(
            "/storage/:network/:storage_id/binaries/:id",
            get(serve_binary).head(serve_binary),
        )
        .layer(middleware::map_response(not_found))
}

/// Serve a binary from the storage or a redirect to the binary
async fn serve_binary(
    Path((network, storage_id, binary_id)): Path<(NetworkId, StorageId, InternedId)>,
    State(state): State<AppState>,
    req: Request,
) -> Response {
    let storage = unwrap_or_not_found!(state.storage.get(&(network, storage_id))).clone();

    let (id, entry) = match storage.resolve_binary_entry(binary_id) {
        Ok(res) => res,
        Err(e) => return ServerError::from(e).into_response(),
    };

    respond_from_entry(id, entry, req).await
}

/// Given a binary entry, respond with the binary or a redirect to the binary
async fn respond_from_entry(id: InternedId, entry: &BinaryEntry, req: Request) -> Response {
    match &entry.source {
        BinarySource::Url(url) => Redirect::temporary(url.as_str()).into_response(),
        BinarySource::Path(file) => {
            if !file.exists() {
                return ServerError::from(StorageError::BinaryFileMissing(id, file.clone()))
                    .into_response();
            }
            ServeFile::new(file).call(req).await.into_response()
        }
    }
}

async fn serve_file(
    Path((network, storage_id, file)): Path<(NetworkId, StorageId, String)>,
    State(state): State<AppState>,
    req: Request,
) -> Response {
    let storage = unwrap_or_not_found!(state.storage.get(&(network, storage_id))).clone();
    let file_path = storage.path(&state).join(&file);

    match file.as_str() {
        // ensure genesis is only served if native genesis is disabled
        "genesis.block" => {
            if storage.native_genesis {
                return StatusCode::NOT_FOUND.into_response();
            }
        }
        // allow ledger.tar.gz to be served
        "ledger.tar.gz" => {}
        // allow checkpoints to be served
        _ if file.ends_with(".checkpoint") => {}
        // serve the version file
        "version" => {}
        // otherwise, return a 404
        _ => return StatusCode::NOT_FOUND.into_response(),
    }

    // ensure the file exists
    if !file_path.exists() {
        return StatusCode::NOT_FOUND.into_response();
    }

    // serve the file
    ServeFile::new(file_path).call(req).await.into_response()
}