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
|
use anyhow::anyhow;
use autofeur::save::Save;
use hyper::http::{Request, Response};
use hyper::{server::Server, Body};
use std::collections::HashMap;
use std::{fs, net::SocketAddr, sync::Arc};
use tower::{make::Shared, ServiceBuilder};
use tower_http::add_extension::AddExtensionLayer;
use url::form_urlencoded::parse;
fn anyhow_response(err: anyhow::Error) -> Response<Body> {
Response::builder()
.status(400)
.body(Body::from(err.root_cause().to_string()))
.unwrap()
}
async fn handler(request: Request<Body>) -> Result<Response<Body>, hyper::Error> {
let save: &Arc<Save> = request.extensions().get().unwrap();
let query = match request
.uri()
.query()
.ok_or_else(|| anyhow_response(anyhow!("query does not exists")))
{
Ok(ok) => ok,
Err(err) => return Ok(err),
};
let params: HashMap<String, String> = request
.uri()
.query()
.map(|v| {
url::form_urlencoded::parse(v.as_bytes())
.into_owned()
.collect()
})
.unwrap_or_else(HashMap::new);
let data = match params
.get("grapheme")
.ok_or_else(|| anyhow_response(anyhow!("grapheme argument is not specified")))
{
Ok(ok) => ok.clone(),
Err(err) => return Ok(err),
};
let infered = match save
.inference(&data)
.await
.or_else(|e| Err(anyhow_response(e.context("inference error"))))
{
Ok(ok) => ok,
Err(e) => return Ok(e),
};
Ok(Response::builder().body(Body::from(infered)).unwrap())
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let data = Box::leak(Box::new(fs::read("assets/db.bin").unwrap()));
let checkpoint: Save = bincode::deserialize(data).unwrap();
let service = ServiceBuilder::new()
.layer(AddExtensionLayer::new(Arc::new(checkpoint)))
// Wrap a `Service` in our middleware stack
.service_fn(handler);
// And run our service using `hyper`
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
Server::bind(&addr)
.http1_only(true)
.serve(Shared::new(service))
.await
.expect("server error");
Ok(())
}
|
