rojo-rbx/rojo
1
0
Fork 1
mirror of https://github.com/rojo-rbx/rojo.git synced 2026-04-22 21:55:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade to Tokio 1.x, futures 0.3, Hyper 0.14, etc (#459)

Browse Source 
* Upgrade dependencies, oneshot channel ref

* New service style?

* Fix warning

* A server is running again

* Working server with async blocks

* UI working again

* Finish upgrade

* Bump MSRV to 1.46.0 for if/match in const fn

* Update the README as part of this
This commit is contained in:
Lucien Greathouse
2021-07-28 12:29:46 -04:00
committed by GitHub
parent 4aa5814a0a
commit 5d62bf9b60
10 changed files with 422 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/web/mod.rs
View File

@@ -8,50 +8,19 @@ pub mod interface;
mod ui;
mod util;
use std::{net::SocketAddr, sync::Arc};
use std::convert::Infallible;
use std::net::SocketAddr;
use std::sync::Arc;
use futures::{
future::{self, FutureResult},
Future,
use hyper::{
server::Server,
service::{make_service_fn, service_fn},
Body, Request,
};
use hyper::{service::Service, Body, Request, Response, Server};
use log::trace;
use tokio::runtime::Runtime;
use crate::serve_session::ServeSession;
use self::{api::ApiService, ui::UiService};
pub struct RootService {
api: ApiService,
ui: UiService,
}
impl Service for RootService {
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
type Future = Box<dyn Future<Item = Response<Self::ReqBody>, Error = Self::Error> + Send>;
fn call(&mut self, request: Request<Self::ReqBody>) -> Self::Future {
trace!("{} {}", request.method(), request.uri().path());
if request.uri().path().starts_with("/api") {
self.api.call(request)
} else {
self.ui.call(request)
}
}
}
impl RootService {
pub fn new(serve_session: Arc<ServeSession>) -> Self {
RootService {
api: ApiService::new(Arc::clone(&serve_session)),
ui: UiService::new(Arc::clone(&serve_session)),
}
}
}
pub struct LiveServer {
serve_session: Arc<ServeSession>,
}
@@ -62,14 +31,31 @@ impl LiveServer {
}
pub fn start(self, address: SocketAddr) {
let server = Server::bind(&address)
.serve(move || {
let service: FutureResult<_, hyper::Error> =
future::ok(RootService::new(Arc::clone(&self.serve_session)));
service
})
.map_err(|e| eprintln!("Server error: {}", e));
let serve_session = Arc::clone(&self.serve_session);
hyper::rt::run(server);
let make_service = make_service_fn(move |_conn| {
let serve_session = Arc::clone(&serve_session);
async {
let service = move |req: Request<Body>| {
let serve_session = Arc::clone(&serve_session);
async move {
if req.uri().path().starts_with("/api") {
Ok::<_, Infallible>(api::call(serve_session, req).await)
} else {
Ok::<_, Infallible>(ui::call(serve_session, req).await)
}
}
};
Ok::<_, Infallible>(service_fn(service))
}
});
let rt = Runtime::new().unwrap();
let _guard = rt.enter();
let server = Server::bind(&address).serve(make_service);
rt.block_on(server).unwrap();
}
}