add juniper-websocket example

examples/juniper-websocket/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "juniper-websocket"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+workspace = "../.."
+
+[[bin]]
+name = "server"
+path = "src/main.rs"
+
+[[bin]]
+name = "client"
+path = "src/client.rs"
+
+[dependencies]
+env_logger = "*"
+futures = "0.1"
+tokio-core = "0.1"
+actix = "0.5"
+actix-web = { path="../../" }
+juniper = "0.9.2"
+lazy_static = "1.0"
+serde_json = "1.0"

examples/juniper-websocket/README.md

@@ -0,0 +1,25 @@
+# juniper-websockect
+
+Simple echo websocket server which handles graphql requests.
+
+## Usage
+
+### server
+
+```bash
+cd actix-web/examples/juniper-websocket
+cargo run --bin server
+# Started http server: 127.0.0.1:8080
+```
+
+### web client
+
+- [http://localhost:8080/graphiql](http://localhost:8080/graphiql)
+
+### rust client
+
+```bash
+cd actix-web/examples/juniper-websocket
+cargo run --bin client
+# Started http server: 127.0.0.1:8080
+```

examples/juniper-websocket/src/client.rs

@@ -0,0 +1,113 @@
+//! Simple websocket client.
+
+#![allow(unused_variables)]
+extern crate actix;
+extern crate actix_web;
+extern crate env_logger;
+extern crate futures;
+extern crate tokio_core;
+
+use std::{io, thread};
+use std::time::Duration;
+
+use actix::*;
+use futures::Future;
+use actix_web::ws::{Message, WsClientError, WsClient, WsClientWriter};
+
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    let _ = env_logger::init();
+    let sys = actix::System::new("ws-example");
+
+    Arbiter::handle().spawn(
+        WsClient::new("http://127.0.0.1:8080/ws/")
+            .connect().unwrap()
+            .map_err(|e| {
+                println!("Error: {}", e);
+                ()
+            })
+            .map(|(reader, writer)| {
+                let addr: Addr<Syn, _> = ChatClient::create(|ctx| {
+                    ChatClient::add_stream(reader, ctx);
+                    ChatClient(writer)
+                });
+
+                // start console loop
+                thread::spawn(move|| {
+                    loop {
+                        let mut cmd = String::new();
+                        if io::stdin().read_line(&mut cmd).is_err() {
+                            println!("error");
+                            return
+                        }
+                        addr.do_send(ClientCommand(cmd));
+                    }
+                });
+
+                ()
+            })
+    );
+
+    let _ = sys.run();
+}
+
+
+struct ChatClient(WsClientWriter);
+
+#[derive(Message)]
+struct ClientCommand(String);
+
+impl Actor for ChatClient {
+    type Context = Context<Self>;
+
+    fn started(&mut self, ctx: &mut Context<Self>) {
+        // start heartbeats otherwise server will disconnect after 10 seconds
+        self.hb(ctx)
+    }
+
+    fn stopped(&mut self, _: &mut Context<Self>) {
+        println!("Disconnected");
+
+        // Stop application on disconnect
+        Arbiter::system().do_send(actix::msgs::SystemExit(0));
+    }
+}
+
+impl ChatClient {
+    fn hb(&self, ctx: &mut Context<Self>) {
+        ctx.run_later(Duration::new(1, 0), |act, ctx| {
+            act.0.text(r#"{"operationName":"K","query":"query K {   human(id: \"213\") {     id     name     homePlanet   } }","variables":"{}"}"#);
+            act.hb(ctx);
+        });
+    }
+}
+
+/// Handle stdin commands
+impl Handler<ClientCommand> for ChatClient {
+    type Result = ();
+
+    fn handle(&mut self, msg: ClientCommand, ctx: &mut Context<Self>) {
+        self.0.text(msg.0.as_str())
+    }
+}
+
+/// Handle server websocket messages
+impl StreamHandler<Message, WsClientError> for ChatClient {
+
+    fn handle(&mut self, msg: Message, ctx: &mut Context<Self>) {
+        match msg {
+            Message::Text(txt) => println!("Server: {:?}", txt),
+            _ => ()
+        }
+    }
+
+    fn started(&mut self, ctx: &mut Context<Self>) {
+        println!("Connected");
+    }
+
+    fn finished(&mut self, ctx: &mut Context<Self>) {
+        println!("Server disconnected");
+        ctx.stop()
+    }
+}

examples/juniper-websocket/src/main.rs

@@ -0,0 +1,145 @@
+//! Simple echo websocket server.
+//! Open `http://localhost:8080/ws/index.html` in browser
+//! or [python console client](https://github.com/actix/actix-web/blob/master/examples/websocket-client.py)
+//! could be used for testing.
+
+#![allow(unused_variables)]
+extern crate actix;
+extern crate actix_web;
+extern crate env_logger;
+#[macro_use]
+extern crate juniper;
+#[macro_use]
+extern crate lazy_static;
+extern crate serde_json;
+
+use actix::*;
+use actix_web::*;
+use juniper::http::GraphQLRequest;
+
+mod schema;
+
+use schema::Schema;
+use schema::create_schema;
+
+lazy_static! {
+    static ref SCHEMA: Schema = create_schema();
+}
+
+fn graphiql(_req: HttpRequest) -> Result<HttpResponse> {
+    let html = r#"
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>GraphQL</title>
+            <style>
+                html, body, #app {
+                    height: 100%;
+                    margin: 0;
+                    overflow: hidden;
+                    width: 100%;
+                }
+            </style>
+            <link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/graphiql/0.10.2/graphiql.css">
+        </head>
+        <body>
+            <div id="app"></div>
+            <script src="//cdnjs.cloudflare.com/ajax/libs/fetch/2.0.3/fetch.js"></script>
+            <script src="//cdnjs.cloudflare.com/ajax/libs/react/16.2.0/umd/react.production.min.js"></script>
+            <script src="//cdnjs.cloudflare.com/ajax/libs/react-dom/16.2.0/umd/react-dom.production.min.js"></script>
+            <script src="//cdnjs.cloudflare.com/ajax/libs/graphiql/0.11.11/graphiql.min.js"></script>
+            <script>
+                var wsUri = (window.location.protocol=='https:'&&'wss://'||'ws://')+window.location.host + '/ws/';
+                promiseResolver = null;
+                conn = new WebSocket(wsUri);
+                console.log('Connecting...');
+                conn.onopen = function() {
+                    console.log('Connected.');
+                    ReactDOM.render(React.createElement(GraphiQL, { fetcher: graphQLFetcher }), document.querySelector('#app'));
+                };
+                conn.onmessage = function(e) {
+                    console.log('Received: ' + e.data);
+                    if (promiseResolver) {
+                        try {
+                            promiseResolver(JSON.parse(e.data));
+                        } catch (error) {
+                            promiseResolver(e.data);
+                        }
+                    }
+                };
+                conn.onclose = function() {
+                    console.log('Disconnected.');
+                    conn = null;
+                };
+                function graphQLFetcher(params) {
+                    return new Promise((resolve) => {
+                        promiseResolver = resolve;
+                        conn.send(JSON.stringify(params));
+                    })
+                }
+            </script>
+        </body>
+        </html>
+    "#;
+    Ok(HttpResponse::build(StatusCode::OK)
+        .content_type("text/html; charset=utf-8")
+        .body(html)
+        .unwrap())
+}
+
+/// do websocket handshake and start `MyWebSocket` actor
+fn ws_index(r: HttpRequest) -> Result<HttpResponse> {
+    ws::start(r, MyWebSocket)
+}
+
+/// websocket connection is long running connection, it easier
+/// to handle with an actor
+struct MyWebSocket;
+
+impl Actor for MyWebSocket {
+    type Context = ws::WebsocketContext<Self>;
+}
+
+/// Handler for `ws::Message`
+impl Handler<ws::Message> for MyWebSocket {
+    type Result = ();
+
+    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
+        match msg {
+            ws::Message::Ping(msg) => ctx.pong(&msg),
+            ws::Message::Text(text) => {
+                println!("server req: {}", text);
+                let req: GraphQLRequest = serde_json::from_str(&text).unwrap();
+                let res = req.execute(&SCHEMA, &());
+                let res_text = serde_json::to_string(&res).unwrap();
+                ctx.text(res_text)
+            }
+            ws::Message::Binary(bin) => ctx.binary(bin),
+            ws::Message::Closed | ws::Message::Error => {
+                ctx.stop();
+            }
+            _ => (),
+        }
+    }
+}
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    let _ = env_logger::init();
+    let sys = actix::System::new("ws-example");
+    let schema = create_schema();
+
+    let _addr = HttpServer::new(
+        || Application::new()
+            // enable logger
+            .middleware(middleware::Logger::default())
+            // websocket route
+            .resource("/ws/", |r| r.method(Method::GET).f(ws_index))
+            .resource("/graphiql", |r| r.method(Method::GET).f(graphiql)))
+        // start http server on 127.0.0.1:8080
+        .bind("127.0.0.1:8080").unwrap()
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

examples/juniper-websocket/src/schema.rs

@@ -0,0 +1,58 @@
+use juniper::FieldResult;
+use juniper::RootNode;
+
+#[derive(GraphQLEnum)]
+enum Episode {
+    NewHope,
+    Empire,
+    Jedi,
+}
+
+#[derive(GraphQLObject)]
+#[graphql(description = "A humanoid creature in the Star Wars universe")]
+struct Human {
+    id: String,
+    name: String,
+    appears_in: Vec<Episode>,
+    home_planet: String,
+}
+
+#[derive(GraphQLInputObject)]
+#[graphql(description = "A humanoid creature in the Star Wars universe")]
+struct NewHuman {
+    name: String,
+    appears_in: Vec<Episode>,
+    home_planet: String,
+}
+
+pub struct QueryRoot;
+
+graphql_object!(QueryRoot: () |&self| {
+    field human(&executor, id: String) -> FieldResult<Human> {
+        Ok(Human{
+            id: "1234".to_owned(),
+            name: "Luke".to_owned(),
+            appears_in: vec![Episode::NewHope],
+            home_planet: "Mars".to_owned(),
+        })
+    }
+});
+
+pub struct MutationRoot;
+
+graphql_object!(MutationRoot: () |&self| {
+    field createHuman(&executor, new_human: NewHuman) -> FieldResult<Human> {
+        Ok(Human{
+            id: "1234".to_owned(),
+            name: new_human.name,
+            appears_in: new_human.appears_in,
+            home_planet: new_human.home_planet,
+        })
+    }
+});
+
+pub type Schema = RootNode<'static, QueryRoot, MutationRoot>;
+
+pub fn create_schema() -> Schema {
+    Schema::new(QueryRoot {}, MutationRoot {})
+}