trusted 0.2.1 → 0.3.2

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

@@ -0,0 +1,58 @@
+use std::sync::mpsc::Sender;
+
+use ruru::{AnyObject, Class, NilClass, Object};
+
+use ruby::Response;
+use response::Response as RustResponse;
+
+lazy_static! {
+    static ref OBSERVER_CLASS: Class = {
+        Class::from_existing("Trusted")
+            .get_nested_class("Request")
+            .get_nested_class("Observer")
+    };
+}
+
+pub struct ObserverData {
+    sender: Sender<RustResponse>,
+}
+
+wrappable_struct!(ObserverData, ObserverWrapper, OBSERVER_DATA_TYPE);
+
+class!(Observer);
+
+unsafe_methods!(
+    Observer,
+    itself,
+
+    // This method is called when the `Future` finishes its execution
+    // (when request is processed by Rack stack)
+    //
+    // Extract `Sender` which points to the corresponding Hyper handler and
+    // send response to it
+    fn update(_time: AnyObject, response: Response, _reason: AnyObject) -> NilClass {
+        let data = itself.get_data(&*OBSERVER_DATA_TYPE);
+
+        data.sender.send(response.into()).unwrap();
+
+        NilClass::new()
+    }
+);
+
+impl Observer {
+    pub fn define_ruby_class() {
+        let data_class = Class::from_existing("Data");
+
+        Class::from_existing("Trusted")
+            .get_nested_class("Request")
+            .define_nested_class("Observer", Some(&data_class))
+            .define(|itself| {
+                itself.def("update", update);
+            });
+    }
+
+    pub fn new(sender: Sender<RustResponse>) -> Self {
+        let observer_data = ObserverData { sender: sender };
+        (*OBSERVER_CLASS).wrap_data(observer_data, &*OBSERVER_DATA_TYPE)
+    }
+}

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

@@ -0,0 +1,17 @@
+use ruru::Object;
+
+use ruby::request::Observer;
+use ruby::Response;
+use ruby::Request;
+
+class!(ProcessingPool);
+
+impl ProcessingPool {
+    pub fn process(&self, request: Request, response: Response, observer: Observer) {
+        let args = vec![request.to_any_object(),
+                        response.to_any_object(),
+                        observer.to_any_object()];
+
+        self.send("execute_future", args);
+    }
+}

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

@@ -0,0 +1,84 @@
+use std::convert::From;
+
+use ruru::{Class, Hash, Object, RString};
+
+use request::{REQUEST_DATA_TYPE, Request as RustRequest};
+
+lazy_static! {
+    static ref REQUEST_CLASS: Class = {
+        Class::from_existing("Trusted").get_nested_class("Request").get_nested_class("Request")
+    };
+}
+
+class!(Request);
+
+methods!(
+    Request,
+    itself,
+
+    fn method() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).method())
+    }
+
+    fn uri() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).url())
+    }
+
+    fn path_info() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).path_info())
+    }
+
+    fn query_string() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).query_string())
+    }
+
+    fn remote_addr() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).remote_addr())
+    }
+
+    fn server_port() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).server_port())
+    }
+
+    fn headers() -> Hash {
+        let mut headers = Hash::new();
+
+        for header in itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).headers().iter() {
+            let field = header.name().to_string().replace("-", "_").to_uppercase();
+            let value = header.value_string();
+
+            let field = format!("HTTP_{}", field);
+
+            headers.store(RString::new(&field), RString::new(&value));
+        }
+
+        headers
+    }
+
+    fn body() -> RString {
+        RString::new(itself.get_data::<RustRequest>(&*REQUEST_DATA_TYPE).body())
+    }
+);
+
+impl Request {
+    pub fn define_ruby_class() {
+        Class::from_existing("Trusted")
+            .get_nested_class("Request")
+            .define_nested_class("Request", None).define(|itself| {
+                itself.def("method", method);
+                itself.def("uri", uri);
+                itself.def("path_info", path_info);
+                itself.def("query_string", query_string);
+                itself.def("remote_addr", remote_addr);
+                itself.def("server_port", server_port);
+                itself.def("headers", headers);
+                itself.def("body", body);
+            });
+    }
+}
+
+impl From<RustRequest> for Request {
+    fn from(request: RustRequest) -> Self {
+        (*REQUEST_CLASS).wrap_data(request, &*REQUEST_DATA_TYPE)
+    }
+}

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

@@ -10,6 +10,14 @@ lazy_static! {
 class!(Response);
 
 impl Response {
+    pub fn define_ruby_class() {
+        Class::from_existing("Trusted").define_nested_class("Response", None).define(|itself| {
+            itself.attr_accessor("status");
+            itself.attr_accessor("headers");
+            itself.attr_accessor("body");
+        });
+    }
+
     pub fn new() -> Self {
         let response = (*RESPONSE_CLASS).new_instance(vec![]);
 

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

@@ -1,8 +1,10 @@
 use std::error::Error;
 
-use ruru::{Class, NilClass, RString, Object, VM};
+use ruru::{Class, NilClass, Object, VM};
 
-use server::Server as RustServer;
+use core::Server as RustServer;
+use config::Config as RustConfig;
+use ruby::Config;
 
 class!(Server);
 
@@ -10,12 +12,12 @@ methods!(
     Server,
     itself,
 
-    fn initialize(addr: RString) -> Server {
-        if let Err(ref error) = addr {
+    fn initialize(config: Config) -> Server {
+        if let Err(ref error) = config {
             VM::raise(error.to_exception(), error.description());
         }
 
-        itself.instance_variable_set("@addr", addr.unwrap());
+        itself.instance_variable_set("@config", config.unwrap());
 
         itself
     }
@@ -23,10 +25,10 @@ methods!(
     fn listen() -> NilClass {
         let handler = VM::block_proc();
 
-        // We can use unsafe here, because the type of addr is checked in the constructor
-        let addr = unsafe { itself.instance_variable_get("@addr").to::<RString>().to_string() };
+        // We can use unsafe here, because the type of @config is checked in the constructor
+        let config = unsafe { itself.instance_variable_get("@config").to::<Config>() };
 
-        RustServer::new(addr).listen(handler);
+        RustServer::new(RustConfig::from(config)).listen(handler);
 
         NilClass::new()
     }

data/lib/rack/handler/trusted.rb

@@ -6,12 +6,11 @@ module Rack
   module Handler
     class Trusted
       def self.run(app, options = {})
-        ::Trusted::Server.new("0.0.0.0:3000").listen do |request, response|
+        config = options[:trusted_config] || ::Trusted::Config::Builder.new.build
+
+        ::Trusted::Server.new(config).listen do |request, response|
           puts "REQUEST: [#{request.method}] #{request.uri}"
           puts "PATH_INFO: #{request.path_info}"
-          puts "QUERY_STRING: #{request.query_string}"
-          puts "REMOTE_ADDR: #{request.remote_addr.inspect}"
-          puts "SERVER_PORT: #{request.server_port.inspect}"
           puts "REQUEST HEADERS: #{request.headers.inspect}"
 
           rack_input = StringIO::new(request.body)
@@ -28,7 +27,7 @@ module Rack
             'rack.version' => Rack::VERSION,
             'rack.input' => rack_input,
             'rack.errors' => $stderr,
-            'rack.multithread' => false,
+            'rack.multithread' => true,
             'rack.multiprocess' => false,
             'rack.run_once' => false,
             'rack.url_scheme' => 'http',
@@ -47,6 +46,8 @@ module Rack
           body.each { |b| response.body.concat(b) }
 
           body.close if body.respond_to?(:close)
+
+          response
         end
       end
     end

data/lib/trusted/config/builder.rb

@@ -0,0 +1,39 @@
+module Trusted
+  module Config
+    class Builder
+      attr_reader :config
+
+      DEFAULT_CONFIG = {
+        binding_type: :tcp,
+        listen_on: 'localhost:3000',
+        thread_pool_size: 1,
+      }.freeze
+
+      def self.dsl(&block)
+        Docile.dsl_eval(new, &block).build
+      end
+
+      def initialize
+        @config = {}
+      end
+
+      def binding_type(type)
+        config[:binding_type] = type
+      end
+
+      def listen_on(address)
+        config[:listen_on] = address
+      end
+
+      def thread_pool_size(size)
+        config[:thread_pool_size] = size
+      end
+
+      def build
+        configuration = DEFAULT_CONFIG.merge(config)
+
+        Config.new(configuration)
+      end
+    end
+  end
+end

data/lib/trusted/config/config.rb

@@ -0,0 +1,13 @@
+module Trusted
+  module Config
+    class Config
+      attr_reader :binding_type, :listen_on, :thread_pool_size
+
+      def initialize(configuration)
+        @binding_type = configuration[:binding_type]
+        @listen_on = configuration[:listen_on]
+        @thread_pool_size = configuration[:thread_pool_size]
+      end
+    end
+  end
+end

data/lib/trusted/request/processing_pool.rb

@@ -0,0 +1,23 @@
+module Trusted
+  module Request
+    class ProcessingPool
+      attr_reader :handler, :thread_pool
+
+      def initialize(handler, thread_pool_size)
+        @handler = handler
+        @thread_pool = Concurrent::FixedThreadPool.new(thread_pool_size)
+
+        puts "[ruby] Spawning #{thread_pool_size} green thread(s)"
+      end
+
+      private
+
+      def execute_future(request, response, observer)
+        future = Concurrent::Future.new(executor: thread_pool, args: [request, response], &handler)
+
+        future.add_observer(observer)
+        future.execute
+      end
+    end
+  end
+end

data/lib/trusted/version.rb

@@ -1,3 +1,3 @@
 module Trusted
-  VERSION = '0.2.1'
+  VERSION = '0.3.2'
 end

data/lib/trusted.rb

@@ -1,18 +1,20 @@
-require 'fiddle'
+require 'concurrent'
+require 'docile'
+require 'thermite/fiddle'
+
+require 'trusted/config/builder'
+require 'trusted/config/config'
+
+require 'trusted/request/processing_pool'
 
-require 'trusted/request'
-require 'trusted/response'
 require 'trusted/version'
 
 require 'rack/handler/trusted'
 
-library_path = File.expand_path(
-  File.join(File.dirname(__FILE__), 'libtrusted.dylib')
-)
+toplevel_dir = File.dirname(File.dirname(__FILE__))
 
-library = Fiddle::dlopen(library_path)
-function = Fiddle::Function.new(library['initialize_my_app'], [], Fiddle::TYPE_VOIDP)
-function.call
-
-module Trusted
-end
+Thermite::Fiddle.load_module(
+  'initialize_my_app',
+  ruby_project_path: toplevel_dir,
+  cargo_project_path: File.join(toplevel_dir, 'ext', 'trusted')
+)

data/trusted.gemspec

@@ -17,13 +17,17 @@ Gem::Specification.new do |spec|
   spec.extensions << 'Rakefile'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.bindir        = 'bin'
+  spec.executables   = %w(trusted)
+  spec.require_paths = %w(lib)
 
-  spec.add_dependency 'thermite', '~> 0.6.0'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_dependency 'docile', '~> 1.1'
+  spec.add_dependency 'rack', '>= 1.0', '< 3.0'
+  spec.add_dependency 'thermite', '~> 0.7.0'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rspec-its', '~> 1.2'
 end

metadata

@@ -1,29 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: trusted
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Dmitry Gritsay
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2016-10-04 00:00:00.000000000 Z
+date: 2016-12-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: thermite
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,20 +104,35 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 description: Write a longer description or delete this line.
 email:
 - unseductable@gmail.com
-executables: []
+executables:
+- trusted
 extensions:
 - Rakefile
 extra_rdoc_files: []
@@ -84,21 +147,33 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/trusted
 - ext/trusted/Cargo.toml
-- ext/trusted/src/handler.rs
+- ext/trusted/src/config/binding_type.rs
+- ext/trusted/src/config/config.rs
+- ext/trusted/src/config/mod.rs
+- ext/trusted/src/core/channel.rs
+- ext/trusted/src/core/core.rs
+- ext/trusted/src/core/handler.rs
+- ext/trusted/src/core/mod.rs
+- ext/trusted/src/core/server.rs
 - ext/trusted/src/lib.rs
 - ext/trusted/src/request.rs
 - ext/trusted/src/request_processor.rs
 - ext/trusted/src/response.rs
+- ext/trusted/src/ruby/config.rs
 - ext/trusted/src/ruby/mod.rs
-- ext/trusted/src/ruby/request.rs
+- ext/trusted/src/ruby/request/mod.rs
+- ext/trusted/src/ruby/request/observer.rs
+- ext/trusted/src/ruby/request/processing_pool.rs
+- ext/trusted/src/ruby/request/request.rs
 - ext/trusted/src/ruby/response.rs
 - ext/trusted/src/ruby/server.rs
-- ext/trusted/src/server.rs
 - lib/rack/handler/trusted.rb
 - lib/trusted.rb
-- lib/trusted/request.rb
-- lib/trusted/response.rb
+- lib/trusted/config/builder.rb
+- lib/trusted/config/config.rb
+- lib/trusted/request/processing_pool.rb
 - lib/trusted/version.rb
 - trusted.gemspec
 homepage: http://this-week-in-ruru.org/

data/ext/trusted/src/handler.rs

@@ -1,55 +0,0 @@
-use std::io::Write;
-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 request::Request;
-use response::Response;
-
-pub struct Handler {
-    sender: Mutex<Sender<Request>>,
-    receiver: Mutex<Receiver<Response>>,
-}
-
-impl Handler {
-    pub fn new(sender: Sender<Request>, receiver: Receiver<Response>) -> Self {
-        Handler {
-            sender: Mutex::new(sender),
-            receiver: Mutex::new(receiver),
-        }
-    }
-}
-
-impl HyperHandler for Handler {
-    fn handle(&self, hyper_request: HyperRequest, mut hyper_response: HyperResponse) {
-        println!("[hyper] New request received");
-
-        self.sender.lock().unwrap().send(hyper_request.into()).unwrap();
-
-        println!("[hyper] Sent to main thread");
-
-        let response = self.receiver.lock().unwrap().recv().unwrap();
-
-        println!("[hyper] Received response from main thread");
-
-        {
-            let headers = hyper_response.headers_mut();
-            *headers = response.headers;
-        }
-
-        {
-            let status = hyper_response.status_mut();
-            *status = StatusCode::from_u16(response.status);
-        }
-
-        println!("[hyper] Starting to send response to client");
-
-        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/ruby/request.rs

@@ -1,44 +0,0 @@
-use std::convert::From;
-
-use ruru::{Class, Hash, Object, RString};
-
-use request::Request as RustRequest;
-
-lazy_static! {
-    static ref REQUEST_CLASS: Class = {
-        Class::from_existing("Trusted").get_nested_class("Request")
-    };
-}
-
-class!(Request);
-
-impl From<RustRequest> for Request {
-    fn from(request: RustRequest) -> Self {
-        let mut headers = Hash::new();
-
-        for header in request.headers.iter() {
-            let field = header.name().to_string().replace("-", "_").to_uppercase();
-            let value = header.value_string();
-
-            let field = format!("HTTP_{}", field);
-
-            headers.store(RString::new(&field), RString::new(&value));
-        }
-
-        let request = (*REQUEST_CLASS).new_instance(
-            vec![
-                RString::new(&request.method).to_any_object(),
-                RString::new(&request.url).to_any_object(),
-                RString::new(&request.path_info).to_any_object(),
-                RString::new(&request.query_string).to_any_object(),
-                RString::new(&request.remote_addr).to_any_object(),
-                RString::new(&request.server_port).to_any_object(),
-                headers.to_any_object(),
-                RString::new(&request.body).to_any_object(),
-            ]
-        );
-
-        // We can use unsafe here, because request is created by our own code
-        unsafe { request.to::<Self>() }
-    }
-}