probject 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+group :development do
+	gem 'ichannel'
+	gem 'rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Johan Lundahl
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+probject
+========
+
+A lightweight actor-based concurrent object framework with each object running in it's own process.
+
+__How does it work?__
+
+Each new object will fork and open up two UNIX sockets, one for requests and one for responses. Each method invocation on the actor is really asynchronous, but one can wait for the method to return by reading from the response channel.
+
+__Example__
+
+```ruby
+require 'net/http'
+require 'probject'
+
+class GoogleRequester < Probject::Actor
+
+  def do_request
+    @response = Net::HTTP.get('www.google.com', '/')
+  end
+
+  def response_length
+    @response.length
+  end
+end
+
+probjects = []
+
+1.upto 5 do |i|
+  probjects[i] = GoogleRequester.new
+
+  probjects[i].async.do_request
+end
+
+1.upto 5 do |i|
+  puts probjects[i].response_length
+end
+```
+
+__Install__
+
+    $ gem install probject
+
+__License__
+
+Released under the MIT License. See `LICENSE.txt`

data/lib/probject.rb

@@ -0,0 +1,8 @@
+require 'ichannel'
+require 'timeout'
+require 'securerandom'
+
+require_relative 'probject/future'
+require_relative 'probject/response_handler'
+require_relative 'probject/proxy'
+require_relative 'probject/actor'

data/lib/probject/actor.rb

@@ -0,0 +1,169 @@
+module Probject
+
+  class TerminatedError < StandardError; end
+
+  class UnsupportedError < StandardError; end
+
+  class Actor
+
+    def initialize
+      @____request_channel = IChannel.new Marshal
+      response_channel = IChannel.new Marshal
+      @____response_handler = ResponseHandler.new response_channel
+      @____pid = Actor.spawn self, @____request_channel, response_channel
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(@____pid))
+    end
+
+    def pid
+      @____pid
+    end
+
+    def terminate(timeout = 10)
+      raise_if_terminated!
+      @____terminated = true
+      if timeout && timeout != 0
+        begin
+          Timeout.timeout(timeout) do
+            Actor.send_signal(@____pid, 'SIGTERM')
+          end
+        rescue Timeout::Error
+          Actor.kill @____pid
+        end
+      else
+        Actor.kill @____pid
+      end
+    end
+
+    def terminated?
+      @____terminated
+    end
+
+    # asynchronous call
+    # returns nil
+    def async
+      raise_if_terminated!
+      Proxy.new(self, :async)
+    end
+    alias_method :tell, :async
+
+    # asynchronous call
+    # returns Probject::Future
+    def future
+      raise_if_terminated!
+      Proxy.new(self, :future)
+    end
+    alias_method :ask, :future
+
+    def self.finalize(pid)
+      proc { self.kill pid }
+    end
+
+    private
+
+    def raise_if_terminated!
+      if @____terminated
+        raise TerminatedError.new "Process #{@____pid} has been terminated!"
+      end
+    end
+
+    def self.kill(pid, timeout = 0.2)
+      begin
+        Timeout.timeout(timeout) do
+          Actor.send_signal(pid, 'SIGKILL')
+        end
+      rescue Timeout::Error
+        Process.detach pid
+      end
+    end
+
+    def self.send_signal(pid, signal)
+      begin
+        Process.kill signal, pid
+        Process.wait pid
+      rescue SystemCallError
+      end
+    end
+
+    def self.spawn(obj, request_channel, response_channel)
+      pid = fork do
+        termination_requested = false
+        trap :SIGTERM do
+          termination_requested = true
+        end
+        loop do
+          if request_channel.readable?
+            msg = request_channel.get
+            begin
+              method = obj.method("____#{msg[:name]}")
+              if msg[:block_given]
+                response = method.call *msg[:args] do |yielded|
+                  response_channel.put id: msg[:id], type: :yield, value: yielded
+                end
+              else
+                response = method.call *msg[:args]
+              end
+            rescue Exception => e
+              response = e
+            end
+            if msg[:respond]
+              response_channel.put id: msg[:id], type: :return, value: response
+            end
+          elsif termination_requested
+            break
+          else
+            # wait a little before trying again
+            sleep 0.1
+          end
+        end
+      end
+      at_exit do
+        self.kill(pid)
+      end
+      pid
+    end
+
+    def self.method_added(name)
+      @added_methods ||= []
+      return if @added_methods.include? name.to_s
+      @added_methods += [name.to_s, "____#{name}", "____#{name}_async", "____#{name}_future"]
+
+      original_method = instance_method(name)
+
+      # original method is moved to ____name
+      define_method("____#{name}") do |*args, &block|
+        original_method.bind(self).call(*args, &block)
+      end
+
+      # async (tell)
+      define_method("____#{name}_async") do |*args, &block|
+        id = SecureRandom.uuid
+        if block
+          raise UnsupportedError.new "Cannot do asynchronous call when providing a block!"
+        end
+        @____request_channel.put id: id, respond: false, name: name, args: args, block_given: false
+        nil
+      end
+
+      # future (ask)
+      define_method("____#{name}_future") do |*args, &block|
+        id = SecureRandom.uuid
+        @____request_channel.put id: id, respond: true, name: name, args: args, block_given: !block.nil?
+        @____response_handler.register_block(id, block) if block
+        Future.new(@____response_handler, id)
+      end
+      ask = instance_method("____#{name}_future")
+
+      # original method or blocking call
+      # direct call or via channel depending on who is calling
+      define_method(name) do |*args, &block|
+        raise_if_terminated!
+        if @____pid # called from outside probject
+          ask.bind(self).call(*args, &block).get!
+        else # called from the probject itself
+          original_method.bind(self).call(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/probject/future.rb

@@ -0,0 +1,22 @@
+module Probject
+  class Future
+    def initialize(response_handler, id)
+      @response_handler = response_handler
+      @id = id
+    end
+
+    def get
+      @response_handler.get @id
+    end
+
+    def get!
+      response = get
+      raise response if response.kind_of? Exception
+      response
+    end
+
+    def done?
+      @response_handler.done? @id
+    end
+  end
+end

data/lib/probject/proxy.rb

@@ -0,0 +1,14 @@
+module Probject
+  class Proxy
+
+    def initialize(probject, invocation_type)
+      @probject = probject
+      @invocation_type = invocation_type
+    end
+
+    def method_missing(name, *args, &block)
+      method = @probject.method("____#{name}_#{@invocation_type}")
+      method.call(*args, &block)
+    end
+  end
+end

data/lib/probject/response_handler.rb

@@ -0,0 +1,51 @@
+module Probject
+  class ResponseHandler
+
+    def initialize(channel)
+      @channel = channel
+      @responses = {}
+      @blocks = {}
+    end
+
+    def get(id)
+      unless has_result? id
+        until get_result id
+        end
+      end
+      @responses.delete id
+    end
+
+    def done?(id)
+      has_result?(id) || get_results(id)
+    end
+
+    def register_block(id, block)
+      @blocks[id] = block
+    end
+
+    private
+
+    def has_result?(id)
+      @responses.include? id
+    end
+
+    def get_results(id)
+      while @channel.readable?
+        return true if get_result(id)
+      end
+      false
+    end
+
+    def get_result(id)
+      msg = @channel.get
+      if msg[:type] == :return # return
+        @responses[msg[:id]] = msg[:value]
+        @blocks.delete msg[:id] # no more yielding after return
+        return msg[:id] == id
+      else # yield
+        @blocks[msg[:id]].call msg[:value]
+        false
+      end
+    end
+  end
+end

data/probject.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'probject/version'
+
+Gem::Specification.new 'probject', Probject::VERSION do |s|
+  s.summary = "Actor-based concurrent framework with objects running in separate processes"
+  s.description = "A lightweight actor-based concurrent object framework with each object running in it's own process"
+  s.authors = ['Johan Lundahl']
+  s.email = 'yohan.lundahl@gmail.com'
+  s.homepage = 'https://github.com/quezacoatl/probject'
+  s.files = `git ls-files`.split($\)
+  s.executables = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_runtime_dependency 'ichannel', '~> 5.0.1'
+end

data/spec/probject_spec.rb

@@ -0,0 +1,127 @@
+require 'rspec'
+
+require_relative '../lib/probject'
+
+describe Probject::Actor do
+
+  before(:all) do
+    class SubProbject < Probject::Actor
+      attr_accessor :text
+
+      def say_hi
+        "Hi!"
+      end
+
+      def greet
+        "#{say_hi} How are you doing?"
+      end
+
+      def sleep_and_return(value = nil)
+        sleep 1
+        value
+      end
+
+      def using_block
+        yield "Hello block!"
+        yield "2"
+        yield "3"
+      end
+    end
+    @probject = SubProbject.new
+  end
+
+  def count_processes
+    Integer(`ps -ef | grep #{Process.pid} | grep -c -v grep`)
+  end
+
+  it "starts a child process" do
+    count_processes.should == 2
+    @probject.pid.should > Process.pid
+  end
+
+  it "handles simple method calls" do
+    @probject.say_hi.should == "Hi!"
+  end
+
+  it "can also use blocks" do
+    yielded = []
+    @probject.using_block do |y|
+      yielded << y
+    end
+    yielded.shift.should == "Hello block!"
+    yielded.shift.should == "2"
+    yielded.shift.should == "3"
+  end
+
+  it "handles method calls which invokes another method on self" do
+    @probject.greet.should == "Hi! How are you doing?"
+  end
+
+  context "sync" do
+    it "will block until response is received" do
+      @probject.sleep_and_return('test').should == 'test'
+    end
+  end
+
+  describe "#async" do
+    it "returns nil for asyncrhonous invocations" do
+      @probject.async.say_hi.should == nil
+    end
+
+    it "will not block" do
+      start = Time.now
+      @probject.async.sleep_and_return
+      (Time.now - start).should < 0.1
+    end
+
+    it "works to set attributes" do
+      @probject.async.text = '123'
+      @probject.text.should == '123'
+    end
+  end
+
+  describe "#future" do
+    it "knows if it is done" do
+      future = @probject.future.sleep_and_return
+      future.done?.should == false
+      sleep 1.1
+      future.done?.should == true
+    end
+
+    it "can block until it is done" do
+      @probject.future.sleep_and_return('test').get.should == 'test'
+    end
+
+    it "works to have several futures" do
+      a = @probject.future.sleep_and_return('a')
+      b = @probject.future.sleep_and_return('b')
+      c = @probject.future.sleep_and_return('c')
+      b.get.should == 'b'
+      c.get.should == 'c'
+      a.get.should == 'a'
+    end
+  end
+
+  context "terminated probject" do
+
+    before do
+      @probject = SubProbject.new
+      count_processes.should == 3 # yet another probject has been created here
+      @probject.terminate
+    end
+
+    it "terminated the child process" do
+      count_processes.should == 2
+    end
+
+    it "will raise exception on calls after terminated" do
+      expect {@probject.async.say_hi}.to raise_error Probject::TerminatedError
+    end
+
+    describe "#terminated?" do
+      it "returns true if probject has been terminated" do
+        @probject.terminated?.should == true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: probject
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Johan Lundahl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ichannel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+description: A lightweight actor-based concurrent object framework with each object
+  running in it's own process
+email: yohan.lundahl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- lib/probject.rb
+- lib/probject/actor.rb
+- lib/probject/future.rb
+- lib/probject/proxy.rb
+- lib/probject/response_handler.rb
+- probject.gemspec
+- spec/probject_spec.rb
+homepage: https://github.com/quezacoatl/probject
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Actor-based concurrent framework with objects running in separate processes
+test_files:
+- spec/probject_spec.rb