hashslab 0.5.2

A hash table with data accessible by index.
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
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

use std::sync::{Arc, Mutex};

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::get,
    Json, Router,
};
use hashslab::HashSlabMap;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Endpoint {
    url: String,
    state: EndpointState,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
enum EndpointState {
    Connected,
    Disconnected,
}

#[derive(Debug, Serialize, Deserialize)]
struct WithId<T> {
    id: usize,
    #[serde(flatten)]
    data: T,
}

type Endpoints = Arc<Mutex<HashSlabMap<String, EndpointState>>>;

async fn list_endpoints(State(endpoints): State<Endpoints>) -> Json<Vec<WithId<Endpoint>>> {
    let endpoints = {
        let lock = endpoints.lock().unwrap();
        lock.iter_full()
            .map(|(id, url, state)| WithId {
                id,
                data: Endpoint {
                    url: url.clone(),
                    state: *state,
                },
            })
            .collect::<Vec<_>>()
    };
    Json(endpoints)
}

async fn add_endpoint(
    State(endpoints): State<Endpoints>,
    Json(endpoint): Json<Endpoint>,
) -> Json<WithId<Endpoint>> {
    let id = {
        let mut lock = endpoints.lock().unwrap();
        let (idx, _) = lock.insert_full(endpoint.url.clone(), endpoint.state);
        idx
    };
    Json(WithId { id, data: endpoint })
}

async fn get_endpoint(
    Path(id): Path<usize>,
    State(endpoints): State<Endpoints>,
) -> impl IntoResponse {
    let endpoint = {
        let lock = endpoints.lock().unwrap();
        lock.get_index(id).map(|(url, &state)| Endpoint {
            url: url.clone(),
            state,
        })
    };
    if let Some(endpoint) = endpoint {
        (StatusCode::OK, Ok(Json(endpoint)))
    } else {
        (StatusCode::NOT_FOUND, Err(Json("Not found")))
    }
}

async fn remove_endpoint(
    Path(id): Path<usize>,
    State(endpoints): State<Endpoints>,
) -> impl IntoResponse {
    let endpoint = {
        let mut lock = endpoints.lock().unwrap();
        lock.remove_index(id).map(|(url, state)| Endpoint {
            url: url.clone(),
            state,
        })
    };
    if let Some(endpoint) = endpoint {
        (StatusCode::OK, Ok(Json(endpoint)))
    } else {
        (StatusCode::NOT_FOUND, Err(Json("Not found")))
    }
}

#[tokio::main]
async fn main() {
    let endpoints = Arc::new(Mutex::new(HashSlabMap::new()));

    let app = Router::new()
        .route("/endpoints", get(list_endpoints).post(add_endpoint))
        .route("/endpoints/{id}", get(get_endpoint).delete(remove_endpoint))
        .with_state(endpoints);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("Running on {}", listener.local_addr().unwrap());
    axum::serve(listener, app).await.unwrap();
}