Futures shard manager #298 (WIP) (#300)

* futures shard manager

* working shard manager test

* shard manager progress

* cleanup mess

* shard queue processing

* shard queue processing is done!

* remove unused code

* progress (no compile)

* shard manager progress

* add ReconnectQueue

2 files changed, 89 insertions, 0 deletions

diff --git a/examples/dev_shard_manager/Cargo.toml b/examples/dev_shard_manager/Cargo.toml
new file mode 100644
index 0000000..79bfd53
--- /dev/null
+++ b/examples/dev_shard_manager/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "dev_shard_manager"
+version = "0.1.0"
+authors = ["my name <[email protected]>"]
+
+[dependencies]
+serenity = { path = "../../", default-features = true }
+tokio-core = "~0.1"
+futures = "~0.1"
+env_logger = "~0.4"
+
diff --git a/examples/dev_shard_manager/src/main.rs b/examples/dev_shard_manager/src/main.rs
new file mode 100644
index 0000000..77855f3
--- /dev/null
+++ b/examples/dev_shard_manager/src/main.rs
@@ -0,0 +1,78 @@
+extern crate futures;
+extern crate serenity;
+extern crate tokio_core;
+extern crate env_logger;
+
+use serenity::{
+    gateway::{
+        ShardingStrategy,
+        ShardManager,
+        ShardManagerOptions,
+        SimpleReconnectQueue,
+    },
+    model::event::{
+        Event,
+        GatewayEvent,
+    },
+};
+use std::{
+    env, 
+    rc::Rc,
+};
+use tokio_core::reactor::{Core, Handle};
+use futures::{future, Future, Stream};
+
+fn main() {
+    env_logger::init().expect("Error initializing env_logger");
+
+    let mut core = Core::new().expect("Error creating event loop");
+    let future = try_main(core.handle());
+
+    core.run(future).expect("Error running event loop");
+}
+
+fn try_main(handle: Handle) -> Box<Future<Item = (), Error = ()>> {
+    let token = env::var("DISCORD_TOKEN")
+        .expect("Expected a token in the environment");
+
+    let opts = ShardManagerOptions {
+        strategy: ShardingStrategy::multi(4),
+        token: Rc::new(token),
+        ws_uri: Rc::new(String::from("nothing")),
+        queue: SimpleReconnectQueue::new(4),
+    }; 
+
+    let mut shard_manager = ShardManager::new(opts, handle.clone());
+    let future = shard_manager.start()
+        .map_err(|e| println!("Error starting shard manager: {:?}", e));
+
+    handle.spawn(future);
+
+    let future = shard_manager.messages().for_each(move |(shard, message)| {
+        let mut shard = shard.borrow_mut();
+        
+        let event = shard.parse(message)
+            .expect("Could not parse shard stream message");
+
+        shard.process(&event);
+        shard_manager.process(&event);
+
+        match event {
+            GatewayEvent::Dispatch(_, Event::MessageCreate(ev)) => {
+                if ev.message.content == "!ping" {
+                    println!("Pong!");
+                }
+            },
+            GatewayEvent::Dispatch(_, Event::Ready(_)) => {
+                println!("Connected to Discord!");
+            },
+            _ => {
+                // Ignore all other messages.
+            },
+        }
+
+        future::ok(())
+    });
+
+    Box::new(future)
+}