trusted 0.2.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15cfbc475e286b40d3e94ded11c1110cdf10f952
-  data.tar.gz: 60bd0659b8d3cd8fe5051aee181faeecf11965df
+  metadata.gz: fe22de0a36b2b3bc06d99ce763da9541fa65adc8
+  data.tar.gz: 2014461c82af74382935959786d7fb059de8a82c
 SHA512:
-  metadata.gz: 52a189eec45ad712297f14f3db1a5f271f7eefe8a5555f456df635412bd153b66706ddc397c19a567c0df3195ad8012918cac09d949c39a01d8dcb5aa1ca058c
-  data.tar.gz: 1a78a573c140d88142932128aee279b2ba9c501592e66ad735b273a88211601d8cd77397fb3ac1dbcdf2fb4db9db776feaa19a9ea9c5bebcceb69c2726902a1e
+  metadata.gz: 8b5217afe22e37f29b4967f3a0a42309fc57a22b53171a054fb3afaf2eb2fd18afd65542f7f34a38202f30af4d068af5d9078d3e050c741bb0e5f994716a2cbb
+  data.tar.gz: 9b7b02314578c6be323863b20b7841501e9a89638fccf8c24a2b2d04d1331a8a27d6ff57101bf7f813f2bf43e496e81522ee514a9d9e821ae5aec06a5beea855

data/bin/trusted

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'optparse'
+
+require 'trusted'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: trusted [options]"
+
+  opts.on("-c path", "--config PATH", "Load configuration file") do |config|
+    contents = File.read(config)
+
+    # TODO: Move to Builder and use cleanroom instead of eval
+    options[:config] = Trusted::Config::Builder.dsl { eval contents }
+  end
+
+  opts.on("-r path", "--rackup PATH", "Load rackup file") do |rackup|
+    options[:rackup] = rackup
+  end
+end
+
+opt_parser.parse!
+
+config = options[:config] || ::Trusted::Config::Builder.new.build
+rackup = options[:rackup] || 'config.ru'
+
+app, _ = Rack::Builder.parse_file(rackup)
+
+Rack::Handler::Trusted.run(app, trusted_config: config)

data/ext/trusted/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trusted"
-version = "0.2.1"
+version = "0.3.2"
 authors = ["Dmitry Gritsay <dmitry@vinted.com>"]
 
 [lib]
@@ -10,4 +10,4 @@ crate-type = ["dylib"]
 hyper = "0.9.10"
 hyperlocal = { git = "https://github.com/softprops/hyperlocal.git" }
 lazy_static = "0.2.1"
-ruru = "0.8.1"
+ruru = "0.9.2"

data/ext/trusted/src/config/binding_type.rs

@@ -0,0 +1,34 @@
+use std::convert::From;
+
+#[derive(Debug, PartialEq)]
+pub enum BindingType {
+    Tcp,
+    Unix,
+}
+
+impl<'a> From<&'a str> for BindingType {
+    fn from(string: &str) -> Self {
+        match string {
+            "tcp" => BindingType::Tcp,
+            "unix" => BindingType::Unix,
+
+            // TODO: move to `Result` and return `Err`
+            _ => panic!("Unsupported binding type"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_is_converted_from_tcp() {
+        assert_eq!(BindingType::from("tcp"), BindingType::Tcp);
+    }
+
+    #[test]
+    fn it_is_converted_from_unix() {
+        assert_eq!(BindingType::from("unix"), BindingType::Unix);
+    }
+}

data/ext/trusted/src/config/config.rs

@@ -0,0 +1,66 @@
+use ruru::{Fixnum, Object, RString, Symbol};
+
+use ruby::Config as RubyConfig;
+
+use super::BindingType;
+
+pub struct Config {
+    binding_type: BindingType,
+    listen_on: String,
+    thread_pool_size: usize,
+}
+
+impl Config {
+    pub fn new(binding_type: BindingType, listen_on: String, thread_pool_size: usize) -> Self {
+        Config {
+            binding_type: binding_type,
+            listen_on: listen_on,
+            thread_pool_size: thread_pool_size,
+        }
+    }
+
+    #[inline]
+    pub fn binding_type(&self) -> &BindingType {
+        &self.binding_type
+    }
+
+    #[inline]
+    pub fn listen_on(&self) -> &str {
+        &self.listen_on
+    }
+
+    #[inline]
+    pub fn thread_pool_size(&self) -> usize {
+        self.thread_pool_size
+    }
+}
+
+
+impl From<RubyConfig> for Config {
+    fn from(ruby_config: RubyConfig) -> Self {
+        // TODO: raise an exception if it is not a String
+        let listen_on =
+            ruby_config
+                .send("listen_on", vec![])
+                .try_convert_to::<RString>().unwrap()
+                .to_string();
+
+        // TODO: raise an exception if it is not a Symbol
+        let binding_type =
+            ruby_config
+                .send("binding_type", vec![])
+                .try_convert_to::<Symbol>().unwrap()
+                .to_string();
+
+        let binding_type = BindingType::from(binding_type.as_str());
+
+        // TODO: raise an exception if it is not a Symbol
+        let thread_pool_size =
+            ruby_config
+                .send("thread_pool_size", vec![])
+                .try_convert_to::<Fixnum>().unwrap()
+                .to_i64() as usize;
+
+        Config::new(binding_type, listen_on, thread_pool_size)
+    }
+}

data/ext/trusted/src/config/mod.rs

@@ -0,0 +1,5 @@
+mod binding_type;
+mod config;
+
+pub use self::binding_type::BindingType;
+pub use self::config::Config;

data/ext/trusted/src/core/channel.rs

@@ -0,0 +1,25 @@
+use std::sync::mpsc::{Receiver, Sender};
+
+pub struct Channel<S, R> {
+    sender: Sender<S>,
+    receiver: Receiver<R>,
+}
+
+impl<S, R> Channel<S, R> {
+    pub fn new(sender: Sender<S>, receiver: Receiver<R>) -> Self {
+        Channel {
+            sender: sender,
+            receiver: receiver,
+        }
+    }
+
+    #[inline]
+    pub fn sender(&self) -> &Sender<S> {
+        &self.sender
+    }
+
+    #[inline]
+    pub fn receiver(&self) -> &Receiver<R> {
+        &self.receiver
+    }
+}

data/ext/trusted/src/core/core.rs

@@ -0,0 +1,77 @@
+use std::io::Read;
+use std::os::unix::io::AsRawFd;
+use std::os::unix::net::UnixStream;
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use ruru::{Class, Fixnum, Object, Proc, Thread};
+
+use core::{Channel, ResponseFuture};
+use request_processor::RequestProcessor;
+use request::Request;
+use response::Response;
+
+use ruby::request::ProcessingPool;
+
+pub struct Core {
+    channel: Channel<ResponseFuture, Request>,
+    ruby_handler: Proc,
+    fake_stream: UnixStream,
+    thread_pool_size: usize,
+}
+
+impl Core {
+    pub fn new(sender: Sender<ResponseFuture>,
+               receiver: Receiver<Request>,
+               ruby_handler: Proc,
+               fake_stream: UnixStream,
+               thread_pool_size: usize) -> Self {
+
+        Core {
+            channel: Channel::new(sender, receiver),
+            ruby_handler: ruby_handler,
+            fake_stream: fake_stream,
+            thread_pool_size: thread_pool_size,
+        }
+    }
+
+    pub fn run(&mut self) {
+        let args = vec![
+            self.ruby_handler.to_any_object(),
+            Fixnum::new(self.thread_pool_size as i64).to_any_object(),
+        ];
+
+        let processing_pool = Class::from_existing("Trusted")
+            .get_nested_class("Request")
+            .get_nested_class("ProcessingPool")
+            .new_instance(args);
+
+        // Can be casted unsafely, because processing pool is created directly from
+        // ProcessingPool class
+        let processing_pool = unsafe { processing_pool.to::<ProcessingPool>() };
+
+        // Buffer for reading a byte from handlers when a fake socket is ready for reading
+        let mut buffer = [0u8; 1];
+
+        let fd = self.fake_stream.as_raw_fd();
+
+        loop {
+            println!("[rust] Waiting for request");
+
+            // Handler will send one byte when new request is ready for processing
+            // Thread::wait_fd() allows other Ruby threads to be scheduled while Core
+            // is waiting for new requests
+            Thread::wait_fd(fd);
+
+            self.fake_stream.read(&mut buffer).unwrap();
+
+            let request = self.channel.receiver().recv().unwrap();
+            let (response_sender, response_receiver) = mpsc::channel::<Response>();
+
+            self.channel.sender().send(response_receiver).unwrap();
+
+            let observer = ::ruby::request::Observer::new(response_sender);
+
+            RequestProcessor::new(request, &processing_pool).handle(observer);
+        }
+    }
+}

data/ext/trusted/src/core/handler.rs

@@ -0,0 +1,73 @@
+use std::io::Write;
+use std::os::unix::net::UnixStream;
+use std::sync::Mutex;
+use std::sync::mpsc::{Sender, Receiver};
+
+use hyper::server::{Handler as HyperHandler, Request as HyperRequest, Response as HyperResponse};
+use hyper::status::StatusCode;
+
+use core::{Channel, ResponseFuture};
+use request::Request;
+
+pub struct Handler {
+    channel: Mutex<Channel<Request, ResponseFuture>>,
+    stream: Mutex<UnixStream>,
+}
+
+impl Handler {
+    pub fn new(sender: Sender<Request>,
+               receiver: Receiver<ResponseFuture>,
+               stream: UnixStream) -> Self {
+
+        let channel = Channel::new(sender, receiver);
+
+        Handler {
+            channel: Mutex::new(channel),
+            stream: Mutex::new(stream),
+        }
+    }
+
+    fn response_future(&self, request: Request) -> ResponseFuture {
+        let channel = self.channel.lock().unwrap();
+
+        // Tell MRI to switch to main thread by sending data using file descriptor
+        {
+            let buffer = [0u8; 1];
+
+            self.stream.lock().unwrap().write(&buffer).unwrap();
+        }
+
+        channel.sender().send(request).unwrap();
+
+        // Receive a `ResponseFuture`
+        channel.receiver().recv().unwrap()
+    }
+}
+
+impl HyperHandler for Handler {
+    fn handle(&self, hyper_request: HyperRequest, mut hyper_response: HyperResponse) {
+        println!("[hyper] New request received");
+
+        let request = hyper_request.into();
+        let response_future = self.response_future(request);
+
+        // Receive a response
+        let response = response_future.recv().unwrap();
+
+        {
+            let headers = hyper_response.headers_mut();
+            *headers = response.headers;
+        }
+
+        {
+            let status = hyper_response.status_mut();
+            *status = StatusCode::from_u16(response.status);
+        }
+
+        let mut res = hyper_response.start().unwrap();
+        res.write_all(response.body.as_bytes()).unwrap();
+
+        println!("[hyper] Response successfully sent to client");
+        println!("[hyper] ------------------------------------");
+    }
+}

data/ext/trusted/src/core/mod.rs

@@ -0,0 +1,15 @@
+mod channel;
+mod core;
+mod handler;
+mod server;
+
+use std::sync::mpsc::Receiver;
+
+use response::Response;
+
+pub use self::channel::Channel;
+pub use self::core::Core;
+pub use self::handler::Handler;
+pub use self::server::Server;
+
+pub type ResponseFuture = Receiver<Response>;

data/ext/trusted/src/core/server.rs

@@ -0,0 +1,70 @@
+use std::os::unix::net::UnixStream;
+use std::sync::mpsc;
+use std::thread;
+
+use hyper::server::Server as HyperServer;
+use hyperlocal::UnixSocketServer;
+use ruru::{Proc, VM};
+
+use config::{BindingType, Config};
+use core::{Core, Handler, ResponseFuture};
+use request::Request;
+
+pub struct Server {
+    config: Config,
+}
+
+impl Server {
+    pub fn new(config: Config) -> Self {
+        Server { config: config }
+    }
+
+    pub fn listen(self, ruby_handler: Proc) {
+        println!("[rust] Start listening");
+
+        let (handler_stream, core_stream) = UnixStream::pair().unwrap();
+
+        let (request_sender, request_receiver) = mpsc::channel::<Request>();
+        let (response_future_sender, response_future_receiver) = mpsc::channel::<ResponseFuture>();
+
+        let handler = Handler::new(request_sender, response_future_receiver, handler_stream);
+
+        let mut core = Core::new(response_future_sender,
+                                 request_receiver,
+                                 ruby_handler,
+                                 core_stream,
+                                 self.config.thread_pool_size());
+
+        thread::spawn(move || {
+            let handler_function = || -> () {
+                println!("[hyper] GVL released for server thread");
+
+                let thread_pool_size = self.config.thread_pool_size();
+
+                println!("[hyper] Spawning {} native thread(s)", thread_pool_size);
+
+                match *self.config.binding_type() {
+                    BindingType::Unix => {
+                        UnixSocketServer::new(self.config.listen_on()).unwrap()
+                            .handle_threads(handler, thread_pool_size).unwrap();
+                    },
+                    BindingType::Tcp => {
+                        HyperServer::http(self.config.listen_on()).unwrap()
+                            .handle_threads(handler, thread_pool_size).unwrap();
+                    }
+                };
+            };
+
+            let unblock_function = || {
+                ()
+            };
+
+            VM::thread_call_without_gvl(
+                handler_function,
+                Some(unblock_function)
+            );
+        });
+
+        core.run();
+    }
+}

data/ext/trusted/src/lib.rs

@@ -4,16 +4,20 @@
 extern crate hyper;
 extern crate hyperlocal;
 
-mod handler;
+mod config;
+mod core;
 mod request;
 mod request_processor;
 mod response;
 mod ruby;
-mod server;
 
-use ruby::Server;
+use ruby::{Request, Response, Server};
+use ruby::request::Observer;
 
 #[no_mangle]
 pub extern fn initialize_my_app() {
+    Observer::define_ruby_class();
+    Request::define_ruby_class();
+    Response::define_ruby_class();
     Server::define_ruby_class();
 }

data/ext/trusted/src/request.rs

@@ -5,16 +5,81 @@ use hyper::header::Headers;
 use hyper::server::{Request as HyperRequest};
 
 pub struct Request {
-    pub method: String,
-    pub url: String,
-    pub path_info: String,
-    pub query_string: String,
-    pub remote_addr: String,
-    pub server_port: String,
-    pub headers: Headers,
-    pub body: String,
+    method: String,
+    url: String,
+    path_info: String,
+    query_string: String,
+    remote_addr: String,
+    server_port: String,
+    headers: Headers,
+    body: String,
 }
 
+impl Request {
+    pub fn new(method: String,
+               url: String,
+               path_info: String,
+               query_string: String,
+               remote_addr: String,
+               server_port: String,
+               headers: Headers,
+               body: String)
+               -> Self {
+        Request {
+            method: method,
+            url: url,
+            path_info: path_info,
+            query_string: query_string,
+            remote_addr: remote_addr,
+            server_port: server_port,
+            headers: headers,
+            body: body,
+        }
+    }
+
+    #[inline]
+    pub fn method(&self) -> &str {
+        &self.method
+    }
+
+    #[inline]
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+
+    #[inline]
+    pub fn path_info(&self) -> &str {
+        &self.path_info
+    }
+
+    #[inline]
+    pub fn query_string(&self) -> &str {
+        &self.query_string
+    }
+
+    #[inline]
+    pub fn remote_addr(&self) -> &str {
+        &self.remote_addr
+    }
+
+    #[inline]
+    pub fn server_port(&self) -> &str {
+        &self.server_port
+    }
+
+    #[inline]
+    pub fn headers(&self) -> &Headers {
+        &self.headers
+    }
+
+    #[inline]
+    pub fn body(&self) -> &str {
+        &self.body
+    }
+}
+
+wrappable_struct!(Request, RequestWrapper, REQUEST_DATA_TYPE);
+
 impl<'a, 'b> From<HyperRequest<'a, 'b>> for Request {
     fn from(mut request: HyperRequest) -> Self {
         let mut body = String::new();
@@ -32,15 +97,13 @@ impl<'a, 'b> From<HyperRequest<'a, 'b>> for Request {
         let remote_addr = request.remote_addr.ip().to_string();
         let server_port = request.remote_addr.port().to_string();
 
-        Request {
-            method: method,
-            url: url,
-            path_info: path_info,
-            query_string: query_string,
-            remote_addr: remote_addr,
-            server_port: server_port,
-            headers: request.headers,
-            body: body,
-        }
+        Request::new(method,
+                     url,
+                     path_info,
+                     query_string,
+                     remote_addr,
+                     server_port,
+                     request.headers,
+                     body)
     }
 }

data/ext/trusted/src/request_processor.rs

@@ -1,28 +1,24 @@
-use ruru::{Object, Proc};
-
 use request::Request;
-use response::Response;
 use ruby::{Request as RubyRequest, Response as RubyResponse};
+use ruby::request::{Observer, ProcessingPool};
 
 pub struct RequestProcessor<'a> {
     request: Request,
-    ruby_handler: &'a Proc,
+    processing_pool: &'a ProcessingPool,
 }
 
 impl<'a> RequestProcessor<'a> {
-    pub fn new(request: Request, ruby_handler: &'a Proc) -> Self {
+    pub fn new(request: Request, processing_pool: &'a ProcessingPool) -> Self {
         RequestProcessor {
             request: request,
-            ruby_handler: ruby_handler,
+            processing_pool: processing_pool,
         }
     }
 
-    pub fn handle(self) -> Response {
+    pub fn handle(self, observer: Observer) {
         let ruby_request = RubyRequest::from(self.request);
         let ruby_response = RubyResponse::new();
 
-        self.ruby_handler.call(vec![ruby_request.to_any_object(), ruby_response.to_any_object()]);
-
-        ruby_response.into()
+        self.processing_pool.process(ruby_request, ruby_response, observer);
     }
 }

data/ext/trusted/src/ruby/config.rs

@@ -0,0 +1,13 @@
+use ruru::{Object, VerifiedObject};
+
+class!(Config);
+
+impl VerifiedObject for Config {
+    fn is_correct_type<T: Object>(object: &T) -> bool {
+        object.respond_to("binding_type") && object.respond_to("listen_on")
+    }
+
+    fn error_message() -> &'static str {
+        "Error converting to Config"
+    }
+}

data/ext/trusted/src/ruby/mod.rs

@@ -1,7 +1,10 @@
-mod request;
+mod config;
 mod response;
 mod server;
 
-pub use self::request::Request;
+pub mod request;
+
+pub use self::config::Config;
 pub use self::response::Response;
 pub use self::server::Server;
+pub use self::request::Request;

data/ext/trusted/src/ruby/request/mod.rs

@@ -0,0 +1,7 @@
+mod observer;
+mod processing_pool;
+mod request;
+
+pub use self::observer::Observer;
+pub use self::processing_pool::ProcessingPool;
+pub use self::request::Request;