···

       
4921
       
 
       
 "atrium-oauth",

     

       
4922
       
 
       
 "clap",

     

       
4923
       
 
       
 "ctrlc",

     

       
4924
       
-
       
 "env_logger",

     

       
4925
       
 
       
 "foyer",

     

       
4926
       
 
       
 "hickory-resolver",

     

       
4927
       
 
       
 "jetstream",

     
···

       
4938
       
 
       
 "time",

     

       
4939
       
 
       
 "tokio",

     

       
4940
       
 
       
 "tokio-util",

     

       
0
       
 
       

     

       
4941
       
 
       
 "url",

     

       
4942
       
 
       
]

     

       
4943
       
 
       


     

···

       
4921
       
 
       
 "atrium-oauth",

     

       
4922
       
 
       
 "clap",

     

       
4923
       
 
       
 "ctrlc",

     

       
0
       
 
       

     

       
4924
       
 
       
 "foyer",

     

       
4925
       
 
       
 "hickory-resolver",

     

       
4926
       
 
       
 "jetstream",

     
···

       
4937
       
 
       
 "time",

     

       
4938
       
 
       
 "tokio",

     

       
4939
       
 
       
 "tokio-util",

     

       
4940
       
+
       
 "tracing-subscriber",

     

       
4941
       
 
       
 "url",

     

       
4942
       
 
       
]

     

       
4943
       
 
       


     

···

       
10
       
 
       
atrium-oauth = "0.1.3"

     

       
11
       
 
       
clap = { version = "4.5.41", features = ["derive"] }

     

       
12
       
 
       
ctrlc = "3.4.7"

     

       
13
       
-
       
env_logger = "0.11.8"

     

       
14
       
 
       
foyer = { version = "0.18.0", features = ["serde"] }

     

       
15
       
 
       
hickory-resolver = "0.25.2"

     

       
16
       
 
       
jetstream = { path = "../jetstream", features = ["metrics"] }

     
···

       
27
       
 
       
time = { version = "0.3.41", features = ["serde"] }

     

       
28
       
 
       
tokio = { version = "1.47.0", features = ["full"] }

     

       
29
       
 
       
tokio-util = "0.7.15"

     

       
0
       
 
       

     

       
30
       
 
       
url = "2.5.4"

     

···

       
10
       
 
       
atrium-oauth = "0.1.3"

     

       
11
       
 
       
clap = { version = "4.5.41", features = ["derive"] }

     

       
12
       
 
       
ctrlc = "3.4.7"

     

       
0
       
 
       

     

       
13
       
 
       
foyer = { version = "0.18.0", features = ["serde"] }

     

       
14
       
 
       
hickory-resolver = "0.25.2"

     

       
15
       
 
       
jetstream = { path = "../jetstream", features = ["metrics"] }

     
···

       
26
       
 
       
time = { version = "0.3.41", features = ["serde"] }

     

       
27
       
 
       
tokio = { version = "1.47.0", features = ["full"] }

     

       
28
       
 
       
tokio-util = "0.7.15"

     

       
29
       
+
       
tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }

     

       
30
       
 
       
url = "2.5.4"

     

···

       
35
       
 
       


     

       
36
       
 
       
#[tokio::main]

     

       
37
       
 
       
async fn main() -> Result<(), String> {

     

       
38
       
-
       
    env_logger::init();

     

       
39
       
 
       


     

       
40
       
 
       
    let shutdown = CancellationToken::new();

     

       
41
       
 
       


     

···

       
35
       
 
       


     

       
36
       
 
       
#[tokio::main]

     

       
37
       
 
       
async fn main() -> Result<(), String> {

     

       
38
       
+
       
    tracing_subscriber::fmt::init();

     

       
39
       
 
       


     

       
40
       
 
       
    let shutdown = CancellationToken::new();

     

       
41
       
 
       


     

···

       
5
       
 
       
use tokio_util::sync::CancellationToken;

     

       
6
       
 
       


     

       
7
       
 
       
use poem::{

     

       
8
       
-
       
    Endpoint, Route, Server,

     

       
9
       
 
       
    endpoint::make_sync,

     

       
0
       
 
       

     

       
10
       
 
       
    listener::{

     

       
11
       
 
       
        Listener, TcpListener,

     

       
12
       
 
       
        acme::{AutoCert, LETS_ENCRYPT_PRODUCTION},

     

       
13
       
 
       
    },

     

       
0
       
 
       

     

       
14
       
 
       
};

     

       
15
       
 
       
use poem_openapi::{

     

       
16
       
 
       
    ApiResponse, Object, OpenApi, OpenApiService, param::Query, payload::Json, types::Example,

     
···

       
242
       
 
       
            .server("http://localhost:3000")

     

       
243
       
 
       
            .url_prefix("/xrpc");

     

       
244
       
 
       


     

       
245
       
-
       
    let app = Route::new()

     

       
246
       
 
       
        .nest("/", api_service.scalar())

     

       
247
       
 
       
        .nest("/openapi.json", api_service.spec_endpoint())

     

       
248
       
 
       
        .nest("/xrpc/", api_service);

     
···

       
252
       
 
       
            .install_default()

     

       
253
       
 
       
            .expect("alskfjalksdjf");

     

       
254
       
 
       


     

       
255
       
-
       
        let app = app.at("/.well-known/did.json", get_did_doc(&host));

     

       
0
       
 
       

     

       
256
       
 
       


     

       
257
       
 
       
        let auto_cert = AutoCert::builder()

     

       
258
       
 
       
            .directory_url(LETS_ENCRYPT_PRODUCTION)

     
···

       
260
       
 
       
            .build()

     

       
261
       
 
       
            .map_err(ServerError::AcmeBuildError)?;

     

       
262
       
 
       


     

       
263
       
-
       
        Server::new(TcpListener::bind("0.0.0.0:443").acme(auto_cert))

     

       
264
       
-
       
            .name("slingshot")

     

       
265
       
-
       
            .run(app)

     

       
266
       
-
       
            .await

     

       
267
       
-
       
            .map_err(ServerError::ServerExited)

     

       
268
       
 
       
    } else {

     

       
269
       
-
       
        Server::new(TcpListener::bind("127.0.0.1:3000"))

     

       
270
       
-
       
            .name("slingshot")

     

       
271
       
-
       
            .run(app)

     

       
272
       
-
       
            .await

     

       
273
       
-
       
            .map_err(ServerError::ServerExited)

     

       
274
       
 
       
    }

     

       
275
       
 
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
5
       
 
       
use tokio_util::sync::CancellationToken;

     

       
6
       
 
       


     

       
7
       
 
       
use poem::{

     

       
8
       
+
       
    Endpoint, EndpointExt, Route, Server,

     

       
9
       
 
       
    endpoint::make_sync,

     

       
10
       
+
       
    http::Method,

     

       
11
       
 
       
    listener::{

     

       
12
       
 
       
        Listener, TcpListener,

     

       
13
       
 
       
        acme::{AutoCert, LETS_ENCRYPT_PRODUCTION},

     

       
14
       
 
       
    },

     

       
15
       
+
       
    middleware::{Cors, Tracing},

     

       
16
       
 
       
};

     

       
17
       
 
       
use poem_openapi::{

     

       
18
       
 
       
    ApiResponse, Object, OpenApi, OpenApiService, param::Query, payload::Json, types::Example,

     
···

       
244
       
 
       
            .server("http://localhost:3000")

     

       
245
       
 
       
            .url_prefix("/xrpc");

     

       
246
       
 
       


     

       
247
       
+
       
    let mut app = Route::new()

     

       
248
       
 
       
        .nest("/", api_service.scalar())

     

       
249
       
 
       
        .nest("/openapi.json", api_service.spec_endpoint())

     

       
250
       
 
       
        .nest("/xrpc/", api_service);

     
···

       
254
       
 
       
            .install_default()

     

       
255
       
 
       
            .expect("alskfjalksdjf");

     

       
256
       
 
       


     

       
257
       
+
       
        app = app

     

       
258
       
+
       
            .at("/.well-known/did.json", get_did_doc(&host));

     

       
259
       
 
       


     

       
260
       
 
       
        let auto_cert = AutoCert::builder()

     

       
261
       
 
       
            .directory_url(LETS_ENCRYPT_PRODUCTION)

     
···

       
263
       
 
       
            .build()

     

       
264
       
 
       
            .map_err(ServerError::AcmeBuildError)?;

     

       
265
       
 
       


     

       
266
       
+
       
        run(TcpListener::bind("0.0.0.0:443").acme(auto_cert), app).await

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
267
       
 
       
    } else {

     

       
268
       
+
       
        run(TcpListener::bind("127.0.0.1:3000"), app).await

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
269
       
 
       
    }

     

       
270
       
 
       
}

     

       
271
       
+
       


     

       
272
       
+
       
async fn run<L>(listener: L, app: Route) -> Result<(), ServerError>

     

       
273
       
+
       
where

     

       
274
       
+
       
    L: Listener + 'static

     

       
275
       
+
       
{

     

       
276
       
+
       
    let app = app

     

       
277
       
+
       
        .with(Cors::new()

     

       
278
       
+
       
            .allow_method(Method::GET)

     

       
279
       
+
       
            .allow_credentials(false))

     

       
280
       
+
       
        .with(Tracing);

     

       
281
       
+
       
    Server::new(listener)

     

       
282
       
+
       
        .name("slingshot")

     

       
283
       
+
       
        .run(app)

     

       
284
       
+
       
        .await

     

       
285
       
+
       
        .map_err(ServerError::ServerExited)

     

       
286
       
+
       
}