New service module

Readme.md

@@ -53,6 +53,55 @@ fn main() {
 }
 ```
 
+## Creating a Thrift Service
+
+Thrust supports creating Thrift services, backed by non-blocking TCP sockets with Mio.
+
+```thrift
+namespace rust thrift;
+// Start by defining a service in your Thrift file.
+service Flock {
+  bool isLoggedIn(1: string token);
+}
+```
+
+After using Thrust to generate the service in Rust, we can start using it.
+
+```rust
+extern crate thrust;
+// Tangle is a futures implementation
+extern crate tangle;
+
+// The generated Rust module.
+use thrift::Flock;
+
+use thrust::{Spawner, Server};
+use tangle::{Future, Async};
+
+pub struct FlockService;
+
+impl Flock for FlockService {
+  fn isLoggedIn(&mut self, token: String) -> Future<bool> {
+    if &*token == "123" {
+      Async::Ok(true)
+    } else {
+      Async::Ok(false)
+    }
+  }
+}
+
+fn main() {
+  // Create a Spawner to manage Mio event loops.
+  let mut spawner = Spawner::new(None);
+
+  Server::run(&spawner, FlockService);
+
+  spawner.join();
+
+
+}
+```
+
 ## License
 
 MIT &mdash; go ham!

src/lib.rs

@@ -17,6 +17,7 @@ use std::str;
 use std::convert;
 use std::string;
 
+mod server;
 mod parser;
 mod ast;
 mod generator;

src/server.rs

@@ -0,0 +1,28 @@
+use runner::Runner;
+use protocol::{Deserializer, ThriftDeserializer};
+use binary_protocol::BinaryDeserializer;
+use std::io::Cursor;
+
+pub type Default = BinaryDeserializer<Cursor<Vec<u8>>>;
+
+/// Manages incoming RPC requests from a Mio event loop and dispatches it
+/// to a runner that will then deserialize the Thrift message and call the appropriate
+/// RPC function.
+///
+/// The server will also manage the response coming back from the RPC method through
+/// the use of futures. These will be coordinated back to Mio.
+pub struct Server<R: Runner<Default>> {
+    de: Default,
+    runner: R
+}
+
+impl<R> Server<R>
+    where R: Runner<Default>
+{
+    pub fn new(runner: R) -> Server<R> {
+        Server {
+            de: BinaryDeserializer::new(Cursor::new(Vec::new())),
+            runner: runner
+        }
+    }
+}

src/service.rs

@@ -5,6 +5,7 @@ use protocol::{Serializer, ThriftSerializer, ThriftMessage, ThriftDeserializer,
 Deserialize, Serialize, ThriftType, ThriftMessageType, Error};
 use binary_protocol::{BinarySerializer, BinaryDeserializer};
 use tangle::{Future, Async};
+use server::{Server};
 
 use pipeline::MessagePipeline;
 use runner::Runner;

src/spawner.rs

@@ -33,8 +33,8 @@ impl Spawner {
         }
     }
 
-    pub fn (mut self) {
-        for handle in 0..self.handles.len() {
+    pub fn join(mut self) {
+        for handle in self.handles.into_iter() {
             handle.join();
         }
     }