commit a8eb176a4f67cdd3496530abb2f5740eb8060636 · nekomimi.pet/microcosm-rs

+36 -9

constellation/src/server/mod.rs

···

       14
        
       use std::collections::{HashMap, HashSet};

     

       15
        
       use std::time::{Duration, UNIX_EPOCH};

     

       16
        
       use tokio::net::{TcpListener, ToSocketAddrs};

     

       17
       -
       use tokio::task::block_in_place;

     

       18
        
       use tokio_util::sync::CancellationToken;

     

       19
        
       

     

       20
        
       use crate::storage::{LinkReader, StorageStats};

     
···

       34
        
       

     

       35
        
       const INDEX_BEGAN_AT_TS: u64 = 1738083600; // TODO: not this

     

       36
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
       pub async fn serve<S, A>(store: S, addr: A, stay_alive: CancellationToken) -> anyhow::Result<()>

     

       38
        
       where

     

       39
        
           S: LinkReader,

     
···

       45
        
                   "/",

     

       46
        
                   get({

     

       47
        
                       let store = store.clone();

     

       48
       -
                       move |accept| async { block_in_place(|| hello(accept, store)) }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       49
        
                   }),

     

       50
        
               )

     

       51
        
               .route(

     

       52
        
                   "/links/count",

     

       53
        
                   get({

     

       54
        
                       let store = store.clone();

     

       55
       -
                       move |accept, query| async { block_in_place(|| count_links(accept, query, store)) }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       56
        
                   }),

     

       57
        
               )

     

       58
        
               .route(

     
···

       60
        
                   get({

     

       61
        
                       let store = store.clone();

     

       62
        
                       move |accept, query| async {

     

       63
       -
                           block_in_place(|| count_distinct_dids(accept, query, store))

     

       0
        
       
     

       0
        
       
     

       64
        
                       }

     

       65
        
                   }),

     

       66
        
               )

     
···

       69
        
                   get({

     

       70
        
                       let store = store.clone();

     

       71
        
                       move |accept, query| async {

     

       72
       -
                           block_in_place(|| get_backlinks(accept, query, store))

     

       0
        
       
     

       0
        
       
     

       73
        
                       }

     

       74
        
                   }),

     

       75
        
               )

     
···

       77
        
                   "/links",

     

       78
        
                   get({

     

       79
        
                       let store = store.clone();

     

       80
       -
                       move |accept, query| async { block_in_place(|| get_links(accept, query, store)) }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81
        
                   }),

     

       82
        
               )

     

       83
        
               .route(

     
···

       85
        
                   get({

     

       86
        
                       let store = store.clone();

     

       87
        
                       move |accept, query| async {

     

       88
       -
                           block_in_place(|| get_distinct_dids(accept, query, store))

     

       0
        
       
     

       0
        
       
     

       89
        
                       }

     

       90
        
                   }),

     

       91
        
               )

     
···

       95
        
                   get({

     

       96
        
                       let store = store.clone();

     

       97
        
                       move |accept, query| async {

     

       98
       -
                           block_in_place(|| count_all_links(accept, query, store))

     

       0
        
       
     

       0
        
       
     

       99
        
                       }

     

       100
        
                   }),

     

       101
        
               )

     
···

       104
        
                   get({

     

       105
        
                       let store = store.clone();

     

       106
        
                       move |accept, query| async {

     

       107
       -
                           block_in_place(|| explore_links(accept, query, store))

     

       0
        
       
     

       0
        
       
     

       108
        
                       }

     

       109
        
                   }),

     

       110
        
               )

···

       14
        
       use std::collections::{HashMap, HashSet};

     

       15
        
       use std::time::{Duration, UNIX_EPOCH};

     

       16
        
       use tokio::net::{TcpListener, ToSocketAddrs};

     

       17
       +
       use tokio::task::spawn_blocking;

     

       18
        
       use tokio_util::sync::CancellationToken;

     

       19
        
       

     

       20
        
       use crate::storage::{LinkReader, StorageStats};

     
···

       34
        
       

     

       35
        
       const INDEX_BEGAN_AT_TS: u64 = 1738083600; // TODO: not this

     

       36
        
       

     

       37
       +
       fn to500(e: tokio::task::JoinError) -> http::StatusCode {

     

       38
       +
           eprintln!("handler join error: {e}");

     

       39
       +
           http::StatusCode::INTERNAL_SERVER_ERROR

     

       40
       +
       }

     

       41
       +
       

     

       42
        
       pub async fn serve<S, A>(store: S, addr: A, stay_alive: CancellationToken) -> anyhow::Result<()>

     

       43
        
       where

     

       44
        
           S: LinkReader,

     
···

       50
        
                   "/",

     

       51
        
                   get({

     

       52
        
                       let store = store.clone();

     

       53
       +
                       move |accept| async {

     

       54
       +
                           spawn_blocking(|| hello(accept, store))

     

       55
       +
                               .await

     

       56
       +
                               .map_err(to500)?

     

       57
       +
                       }

     

       58
        
                   }),

     

       59
        
               )

     

       60
        
               .route(

     

       61
        
                   "/links/count",

     

       62
        
                   get({

     

       63
        
                       let store = store.clone();

     

       64
       +
                       move |accept, query| async {

     

       65
       +
                           spawn_blocking(|| count_links(accept, query, store))

     

       66
       +
                               .await

     

       67
       +
                               .map_err(to500)?

     

       68
       +
                       }

     

       69
        
                   }),

     

       70
        
               )

     

       71
        
               .route(

     
···

       73
        
                   get({

     

       74
        
                       let store = store.clone();

     

       75
        
                       move |accept, query| async {

     

       76
       +
                           spawn_blocking(|| count_distinct_dids(accept, query, store))

     

       77
       +
                               .await

     

       78
       +
                               .map_err(to500)?

     

       79
        
                       }

     

       80
        
                   }),

     

       81
        
               )

     
···

       84
        
                   get({

     

       85
        
                       let store = store.clone();

     

       86
        
                       move |accept, query| async {

     

       87
       +
                           spawn_blocking(|| get_backlinks(accept, query, store))

     

       88
       +
                               .await

     

       89
       +
                               .map_err(to500)?

     

       90
        
                       }

     

       91
        
                   }),

     

       92
        
               )

     
···

       94
        
                   "/links",

     

       95
        
                   get({

     

       96
        
                       let store = store.clone();

     

       97
       +
                       move |accept, query| async {

     

       98
       +
                           spawn_blocking(|| get_links(accept, query, store))

     

       99
       +
                               .await

     

       100
       +
                               .map_err(to500)?

     

       101
       +
                       }

     

       102
        
                   }),

     

       103
        
               )

     

       104
        
               .route(

     
···

       106
        
                   get({

     

       107
        
                       let store = store.clone();

     

       108
        
                       move |accept, query| async {

     

       109
       +
                           spawn_blocking(|| get_distinct_dids(accept, query, store))

     

       110
       +
                               .await

     

       111
       +
                               .map_err(to500)?

     

       112
        
                       }

     

       113
        
                   }),

     

       114
        
               )

     
···

       118
        
                   get({

     

       119
        
                       let store = store.clone();

     

       120
        
                       move |accept, query| async {

     

       121
       +
                           spawn_blocking(|| count_all_links(accept, query, store))

     

       122
       +
                               .await

     

       123
       +
                               .map_err(to500)?

     

       124
        
                       }

     

       125
        
                   }),

     

       126
        
               )

     
···

       129
        
                   get({

     

       130
        
                       let store = store.clone();

     

       131
        
                       move |accept, query| async {

     

       132
       +
                           spawn_blocking(|| explore_links(accept, query, store))

     

       133
       +
                               .await

     

       134
       +
                               .map_err(to500)?

     

       135
        
                       }

     

       136
        
                   }),

     

       137
        
               )