update websocket-chat example

examples/websocket-chat/src/client.rs

@@ -29,7 +29,7 @@ fn main() {
     Arbiter::handle().spawn(
         TcpStream::connect(&addr, Arbiter::handle())
             .and_then(|stream| {
-                let addr: Addr<Syn<_>> = ChatClient::create(|ctx| {
+                let addr: Addr<Syn, _> = ChatClient::create(|ctx| {
                     let (r, w) = stream.split();
                     ChatClient::add_stream(FramedRead::new(r, codec::ClientChatCodec), ctx);
                     ChatClient{

examples/websocket-chat/src/main.rs

@@ -26,7 +26,7 @@ mod session;
 /// This is our websocket route state, this state is shared with all route instances
 /// via `HttpContext::state()`
 struct WsChatSessionState {
-    addr: Addr<Syn<server::ChatServer>>,
+    addr: Addr<Syn, server::ChatServer>,
 }
 
 /// Entry point for our route
@@ -62,10 +62,10 @@ impl Actor for WsChatSession {
         // before processing any other events.
         // HttpContext::state() is instance of WsChatSessionState, state is shared across all
         // routes within application
-        let addr: Addr<Syn<_>> = ctx.address();
-        ctx.state().addr.call(
-            self, server::Connect{addr: addr.subscriber()}).then(
-            |res, act, ctx| {
+        let addr: Addr<Syn, _> = ctx.address();
+        ctx.state().addr.call(server::Connect{addr: addr.subscriber()})
+            .into_actor(self)
+            .then(|res, act, ctx| {
                 match res {
                     Ok(res) => act.id = res,
                     // something is wrong with chat server
@@ -109,7 +109,9 @@ impl Handler<ws::Message> for WsChatSession {
                         "/list" => {
                             // Send ListRooms message to chat server and wait for response
                             println!("List rooms");
-                            ctx.state().addr.call(self, server::ListRooms).then(|res, _, ctx| {
+                            ctx.state().addr.call(server::ListRooms)
+                                .into_actor(self)
+                                .then(|res, _, ctx| {
                                     match res {
                                         Ok(rooms) => {
                                             for room in rooms {
@@ -172,7 +174,7 @@ fn main() {
     let sys = actix::System::new("websocket-example");
 
     // Start chat server actor in separate thread
-    let server: Addr<Syn<_>> = Arbiter::start(|_| server::ChatServer::default());
+    let server: Addr<Syn, _> = Arbiter::start(|_| server::ChatServer::default());
 
     // Start tcp server in separate thread
     let srv = server.clone();

examples/websocket-chat/src/server.rs

@@ -15,7 +15,7 @@ use session;
 #[derive(Message)]
 #[rtype(usize)]
 pub struct Connect {
-    pub addr: SyncSubscriber<session::Message>,
+    pub addr: Subscriber<Syn, session::Message>,
 }
 
 /// Session is disconnected
@@ -54,7 +54,7 @@ pub struct Join {
 /// `ChatServer` manages chat rooms and responsible for coordinating chat session.
 /// implementation is super primitive
 pub struct ChatServer {
-    sessions: HashMap<usize, SyncSubscriber<session::Message>>,
+    sessions: HashMap<usize, Subscriber<Syn, session::Message>>,
     rooms: HashMap<String, HashSet<usize>>,
     rng: RefCell<ThreadRng>,
 }

examples/websocket-chat/src/session.rs

@@ -24,7 +24,7 @@ pub struct ChatSession {
     /// unique session id
     id: usize,
     /// this is address of chat server
-    addr: Addr<Syn<ChatServer>>,
+    addr: Addr<Syn, ChatServer>,
     /// Client must send ping at least once per 10 seconds, otherwise we drop connection.
     hb: Instant,
     /// joined room
@@ -45,8 +45,9 @@ impl Actor for ChatSession {
         // register self in chat server. `AsyncContext::wait` register
         // future within context, but context waits until this future resolves
         // before processing any other events.
-        let addr: Addr<Syn<_>> = ctx.address();
-        self.addr.call(self, server::Connect{addr: addr.subscriber()})
+        let addr: Addr<Syn, _> = ctx.address();
+        self.addr.call(server::Connect{addr: addr.subscriber()})
+            .into_actor(self)
             .then(|res, act, ctx| {
                 match res {
                     Ok(res) => act.id = res,
@@ -75,7 +76,9 @@ impl StreamHandler<ChatRequest, io::Error> for ChatSession {
             ChatRequest::List => {
                 // Send ListRooms message to chat server and wait for response
                 println!("List rooms");
-                self.addr.call(self, server::ListRooms).then(|res, act, ctx| {
+                self.addr.call(server::ListRooms)
+                    .into_actor(self)
+                    .then(|res, act, ctx| {
                         match res {
                             Ok(rooms) => {
                                 act.framed.write(ChatResponse::Rooms(rooms));
@@ -121,7 +124,7 @@ impl Handler<Message> for ChatSession {
 /// Helper methods
 impl ChatSession {
 
-    pub fn new(addr: Addr<Syn<ChatServer>>,
+    pub fn new(addr: Addr<Syn,ChatServer>,
                framed: actix::io::FramedWrite<WriteHalf<TcpStream>, ChatCodec>) -> ChatSession {
         ChatSession {id: 0, addr: addr, hb: Instant::now(),
                      room: "Main".to_owned(), framed: framed}
@@ -155,11 +158,11 @@ impl ChatSession {
 /// Define tcp server that will accept incoming tcp connection and create
 /// chat actors.
 pub struct TcpServer {
-    chat: Addr<Syn<ChatServer>>,
+    chat: Addr<Syn, ChatServer>,
 }
 
 impl TcpServer {
-    pub fn new(s: &str, chat: Addr<Syn<ChatServer>>) {
+    pub fn new(s: &str, chat: Addr<Syn, ChatServer>) {
         // Create server listener
         let addr = net::SocketAddr::from_str("127.0.0.1:12345").unwrap();
         let listener = TcpListener::bind(&addr, Arbiter::handle()).unwrap();