Merge branch 'upgrade-actor-web-1.0.x' of https://github.com/Jonnnh/lemmy into Jonnnh-upgrade-actor-web-1.0.x

server/Cargo.toml

@@ -6,22 +6,23 @@ edition = "2018"
 
 [dependencies]
 diesel = { version = "1.4.2", features = ["postgres","chrono"] }
-diesel_migrations = "*"
+diesel_migrations = "1.4.0"
-dotenv = "0.9.0"
+dotenv = "0.14.1"
-bcrypt = "0.3"
+bcrypt = "0.5.0"
-activitypub = "0.1.4"
+activitypub = "0.1.5"
-chrono = { version = "0.4", features = ["serde"] }
+chrono = { version = "0.4.7", features = ["serde"] }
 failure = "0.1.5"
-serde_json = "*"
+serde_json = "1.0.40"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0.94", features = ["derive"] }
-actix = "*"
+actix = "0.8.3"
-actix-web = "*"
+actix-web = "1.0"
-env_logger = "*"
+actix-files = "0.1.3"
-rand = "0.6.5"
+actix-web-actors = "1.0"
-strum = "0.14.0"
+env_logger = "0.6.2"
-strum_macros = "0.14.0"
+rand = "0.7.0"
-jsonwebtoken = "*"
+strum = "0.15.0"
-regex = "*"
+strum_macros = "0.15.0"
-lazy_static = "*"
+jsonwebtoken = "6.0.1"
-reqwest = "*"
+regex = "1.1.9"
-openssl = { version = "0.10", features = ["vendored"] }
+lazy_static = "1.3.0"
+

server/src/main.rs

@@ -1,13 +1,15 @@
 extern crate lemmy_server;
-#[macro_use] extern crate diesel_migrations;
+#[macro_use]
+extern crate diesel_migrations;
 
-use std::time::{Instant, Duration};
+use actix::prelude::*;
-use std::env;
+use actix_files::NamedFile;
-use lemmy_server::actix::*;
+use actix_web::*;
-use lemmy_server::actix_web::server::HttpServer;
+use actix_web_actors::ws;
-use lemmy_server::actix_web::{ws, App, Error, HttpRequest, HttpResponse, fs::NamedFile, fs};
-use lemmy_server::websocket::server::*;
 use lemmy_server::db::establish_connection;
+use lemmy_server::websocket::server::*;
+use std::env;
+use std::time::{Duration, Instant};
 
 embed_migrations!();
 
@@ -16,203 +18,196 @@ const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
 /// How long before lack of client response causes a timeout
 const CLIENT_TIMEOUT: Duration = Duration::from_secs(10);
 
-/// This is our websocket route state, this state is shared with all route
-/// instances via `HttpContext::state()`
-struct WsChatSessionState {
-  addr: Addr<ChatServer>,
-}
-
 /// Entry point for our route
-fn chat_route(req: &HttpRequest<WsChatSessionState>) -> Result<HttpResponse, Error> {
+fn chat_route(
-  ws::start(
+    req: HttpRequest,
-    req,
+    stream: web::Payload,
-    WSSession {
+    chat_server: web::Data<Addr<ChatServer>>,
-      id: 0,
+) -> Result<HttpResponse, Error> {
-      hb: Instant::now(),
+    ws::start(
-      ip: req.connection_info()
+        WSSession {
-        .remote()
+            cs_addr: chat_server.get_ref().to_owned(),
-        .unwrap_or("127.0.0.1:12345")
+            id: 0,
-        .split(":")
+            hb: Instant::now(),
-        .next()
+            ip: req
-        .unwrap_or("127.0.0.1")
+                .connection_info()
-        .to_string()
+                .remote()
-    },
+                .unwrap_or("127.0.0.1:12345")
+                .split(":")
+                .next()
+                .unwrap_or("127.0.0.1")
+                .to_string(),
+        },
+        &req,
+        stream,
     )
 }
 
 struct WSSession {
-  /// unique session id
+    cs_addr: Addr<ChatServer>,
-  id: usize,
+    /// unique session id
-  ip: String,
+    id: usize,
-  /// Client must send ping at least once per 10 seconds (CLIENT_TIMEOUT),
+    ip: String,
-  /// otherwise we drop connection.
+    /// Client must send ping at least once per 10 seconds (CLIENT_TIMEOUT),
-  hb: Instant
+    /// otherwise we drop connection.
+    hb: Instant,
 }
 
 impl Actor for WSSession {
-  type Context = ws::WebsocketContext<Self, WsChatSessionState>;
+    type Context = ws::WebsocketContext<Self>;
 
-  /// Method is called on actor start.
+    /// Method is called on actor start.
-  /// We register ws session with ChatServer
+    /// We register ws session with ChatServer
-  fn started(&mut self, ctx: &mut Self::Context) {
+    fn started(&mut self, ctx: &mut Self::Context) {
-    // we'll start heartbeat process on session start.
+        // we'll start heartbeat process on session start.
-    self.hb(ctx);
+        self.hb(ctx);
 
-    // register self in chat server. `AsyncContext::wait` register
+        // register self in chat server. `AsyncContext::wait` register
-    // future within context, but context waits until this future resolves
+        // future within context, but context waits until this future resolves
-    // before processing any other events.
+        // before processing any other events.
-    // HttpContext::state() is instance of WsChatSessionState, state is shared
+        // across all routes within application
-    // across all routes within application
+        let addr = ctx.address();
-    let addr = ctx.address();
+        self.cs_addr
-    ctx.state()
+            .send(Connect {
-      .addr
+                addr: addr.recipient(),
-      .send(Connect {
+                ip: self.ip.to_owned(),
-        addr: addr.recipient(),
+            })
-        ip: self.ip.to_owned(),
+            .into_actor(self)
-      })
+            .then(|res, act, ctx| {
-    .into_actor(self)
+                match res {
-      .then(|res, act, ctx| {
+                    Ok(res) => act.id = res,
-        match res {
+                    // something is wrong with chat server
-          Ok(res) => act.id = res,
+                    _ => ctx.stop(),
-          // something is wrong with chat server
+                }
-          _ => ctx.stop(),
+                fut::ok(())
-        }
+            })
-        fut::ok(())
+            .wait(ctx);
-      })
+    }
-    .wait(ctx);
-  }
 
-  fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
+    fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
-    // notify chat server
+        // notify chat server
-    ctx.state().addr.do_send(Disconnect { 
+        self.cs_addr.do_send(Disconnect {
-      id: self.id,
+            id: self.id,
-      ip: self.ip.to_owned(),
+            ip: self.ip.to_owned(),
-    });
+        });
-    Running::Stop
+        Running::Stop
-  }
+    }
 }
 
 /// Handle messages from chat server, we simply send it to peer websocket
 /// These are room messages, IE sent to others in the room
 impl Handler<WSMessage> for WSSession {
-  type Result = ();
+    type Result = ();
 
-  fn handle(&mut self, msg: WSMessage, ctx: &mut Self::Context) {
+    fn handle(&mut self, msg: WSMessage, ctx: &mut Self::Context) {
-    // println!("id: {} msg: {}", self.id, msg.0);
+        // println!("id: {} msg: {}", self.id, msg.0);
-    ctx.text(msg.0);
+        ctx.text(msg.0);
-  }
+    }
 }
 
 /// WebSocket message handler
 impl StreamHandler<ws::Message, ws::ProtocolError> for WSSession {
-  fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
+    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-    // println!("WEBSOCKET MESSAGE: {:?} from id: {}", msg, self.id);
+        // println!("WEBSOCKET MESSAGE: {:?} from id: {}", msg, self.id);
-    match msg {
+        match msg {
-      ws::Message::Ping(msg) => {
+            ws::Message::Ping(msg) => {
-        self.hb = Instant::now();
+                self.hb = Instant::now();
-        ctx.pong(&msg);
+                ctx.pong(&msg);
-      }
-      ws::Message::Pong(_) => {
-        self.hb = Instant::now();
-      }
-      ws::Message::Text(text) => {
-        let m = text.trim().to_owned();
-        println!("WEBSOCKET MESSAGE: {:?} from id: {}", &m, self.id);
-        
-        ctx.state()
-          .addr
-          .send(StandardMessage {
-            id: self.id,
-            msg: m,
-          })
-        .into_actor(self)
-          .then(|res, _, ctx| {
-            match res {
-              Ok(res) => ctx.text(res),
-              Err(e) => {
-                eprintln!("{}", &e);
-              }
             }
-            fut::ok(())
+            ws::Message::Pong(_) => {
-          })
+                self.hb = Instant::now();
-        .wait(ctx);
+            }
-      }
+            ws::Message::Text(text) => {
-      ws::Message::Binary(_bin) => println!("Unexpected binary"),
+                let m = text.trim().to_owned();
-      ws::Message::Close(_) => {
+                println!("WEBSOCKET MESSAGE: {:?} from id: {}", &m, self.id);
-        ctx.stop();
+
-      },
+                self.cs_addr
+                    .send(StandardMessage {
+                        id: self.id,
+                        msg: m,
+                    })
+                    .into_actor(self)
+                    .then(|res, _, ctx| {
+                        match res {
+                            Ok(res) => ctx.text(res),
+                            Err(e) => {
+                                eprintln!("{}", &e);
+                            }
+                        }
+                        fut::ok(())
+                    })
+                    .wait(ctx);
+            }
+            ws::Message::Binary(_bin) => println!("Unexpected binary"),
+            ws::Message::Close(_) => {
+                ctx.stop();
+            }
+            _ => {}
+        }
     }
-  }
 }
 
 impl WSSession {
-  /// helper method that sends ping to client every second.
+    /// helper method that sends ping to client every second.
-  ///
+    ///
-  /// also this method checks heartbeats from client
+    /// also this method checks heartbeats from client
-  fn hb(&self, ctx: &mut ws::WebsocketContext<Self, WsChatSessionState>) {
+    fn hb(&self, ctx: &mut ws::WebsocketContext<Self>) {
-    ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
+        ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
-      // check client heartbeats
+            // check client heartbeats
-      if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
+            if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
-        // heartbeat timed out
+                // heartbeat timed out
-        println!("Websocket Client heartbeat failed, disconnecting!");
+                println!("Websocket Client heartbeat failed, disconnecting!");
 
-        // notify chat server
+                // notify chat server
-        ctx.state()
+                act.cs_addr.do_send(Disconnect {
-          .addr
+                    id: act.id,
-          .do_send(Disconnect { id: act.id, ip: act.ip.to_owned() });
+                    ip: act.ip.to_owned(),
+                });
 
-        // stop actor
+                // stop actor
-        ctx.stop();
+                ctx.stop();
 
-        // don't try to send a ping
+                // don't try to send a ping
-        return;
+                return;
-      }
+            }
 
-      ctx.ping("");
+            ctx.ping("");
-    });
+        });
-  }
+    }
 }
 
 fn main() {
-  let _ = env_logger::init();
+    let _ = env_logger::init();
-  let sys = actix::System::new("lemmy");
+    let sys = actix::System::new("lemmy");
 
-  // Run the migrations from code
+    // Run the migrations from code
-  let conn = establish_connection();
+    let conn = establish_connection();
-  embedded_migrations::run(&conn).unwrap();
+    embedded_migrations::run(&conn).unwrap();
 
-  // Start chat server actor in separate thread
+    // Start chat server actor in separate thread
-  let server = Arbiter::start(|_| ChatServer::default());
+    let server = ChatServer::default().start();
-
+    // Create Http server with websocket support
-  // Create Http server with websocket support
+    HttpServer::new(move || {
-  HttpServer::new(move || {
+        App::new()
-    // Websocket sessions state
+            .data(server.clone())
-    let state = WsChatSessionState {
+            .service(web::resource("/api/v1/ws").to(chat_route))
-      addr: server.clone(),
+            //            .service(web::resource("/api/v1/rest").route(web::post().to(||{})))
-    };
+            .service(web::resource("/").to(index))
-
+            // static resources
-    App::with_state(state)
+            .service(actix_files::Files::new("/static", front_end_dir()))
-      // .resource("/api/v1/rest", |r| r.method(http::Method::POST).f(|_| {})
+    })
-      .resource("/api/v1/ws", |r| r.route().f(chat_route))
+    .bind("0.0.0.0:8536")
-      // static resources
+    .unwrap()
-      .resource("/", |r| r.route().f(index))
-      .handler(
-        "/static",
-        fs::StaticFiles::new(front_end_dir()).unwrap()
-      )
-      .finish()
-  }).bind("0.0.0.0:8536")
-  .unwrap()
     .start();
 
-  println!("Started http server: 0.0.0.0:8536");
+    println!("Started http server: 0.0.0.0:8536");
-  let _ = sys.run();
+    let _ = sys.run();
 }
 
-fn index(_req: &HttpRequest<WsChatSessionState>) -> Result<NamedFile, actix_web::error::Error> {
+fn index() -> Result<NamedFile, actix_web::error::Error> {
-  Ok(NamedFile::open(front_end_dir() + "/index.html")?)
+    Ok(NamedFile::open(front_end_dir() + "/index.html")?)
 }
 
 fn front_end_dir() -> String {
-  env::var("LEMMY_FRONT_END_DIR").unwrap_or("../ui/dist".to_string())
+    env::var("LEMMY_FRONT_END_DIR").unwrap_or("../ui/dist".to_string())
 }