oleganza-emrpc 0.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Oleg Andreev <oleganza@gmail.com>
+
+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

@@ -0,0 +1,129 @@
+EMRPC is a EventMachine-based remote procedure call library.
+It looks like DRb, but is much more efficient and provides
+asynchronous erlang-like interface along with blocking synchronous interface. 
+
+Author: Oleg Andreev <oleganza@gmail.com>
+
+
+FEATURES
+
+0. Object-oriented evented API based on lightweight processes called Pids.
+1. Automatically reconnecting clients (blocking and evented).
+2. Support for both TCP and Unix sockets. (Use "emrpc://host:port" or "unix:///path/to/my.sock")
+3. Modularity and good specs coverage: EMRPC is easy to learn, extend and optimize.
+
+
+VERSION AND STATUS
+
+This is v0.3 alpha. It is being used in several projects of my own, but is not tested on many interesting cases.
+It has also several issues with performance and specs stability (see TODO file).
+
+
+THANKS TO
+
+* linkfeed.ru for the real-world EMRPC-based application.
+* pierlis.com for the table/chair/wifi in Paris.
+
+
+EXAMPLES
+
+You may try out examples using bin/emrpc IRB session.
+Just open the console and paste the code.
+
+-------------------------------------------------------------------------------
+
+HELLO WORLD (BLOCKING API)
+
+  class HelloWorld
+    def action
+      "Hello!"
+    end
+  end
+    
+  server = EMRPC::Server.new(:address => 'emrpc://localhost:4000/', 
+                             :backend => HelloWorld.new)
+  EM::safe_run(:background) { }
+  
+  server.start
+  
+  client = EMRPC::Client.new('emrpc://localhost:4000/')
+  client.action == "Hello!" #=> true
+
+
+-------------------------------------------------------------------------------
+
+HELLO WORLD (EVENTED API)
+
+  class HelloWorld
+    include Pid
+    def action(sender)
+      puts "HelloWorld replies to the sender #{sender}..."
+      sender.reply(self, "Hello!")
+    end
+  end
+
+  class User
+    include Pid
+    def connected(pid)
+      puts "Pid #{pid} connected with the user."
+      pid.action(self)
+    end
+    def reply(pid, msg)
+      puts "Pid #{pid} replied: #{msg}"
+    end
+  end
+    
+  EM::run do
+    hw = HelloWorld.new
+    hw.bind('emrpc://localhost:4000/')  # bind a pid to the address 
+    
+    oleg = User.new
+    oleg.connect('emrpc://localhost:4000/') # connect to that address
+  end
+  
+  # Output:
+  Pid #<EMRPC::RemotePid:0x143b740> connected with the user.
+  HelloWorld replies to the sender #<User:0x143b4d4>...
+  Pid #<HelloWorld:0x143d540> replied: Hello!
+
+-------------------------------------------------------------------------------
+
+HELLO WORLD (EVENTED WRAPPER, MIXED API)
+
+  # in first process:
+  class HelloWorld
+    def action
+      "Hello!"
+    end
+  end
+  
+  server = EMRPC::Server.new(:address => 'emrpc://localhost:4000/', 
+                             :backend => HelloWorld.new)
+  
+  EM::run do
+    server.start
+  end
+  
+  # in the other process (actually, this works in the same process with the server too):
+  class User
+    include Pid
+    def connected(pid)
+      puts "Pid #{pid} connected to the user."
+      pid.send(self, :action)
+    end
+    def on_return(pid, msg)
+      puts "Pid #{pid} replied: #{msg}"
+    end
+  end
+  
+  EM::run do
+    oleg = User.new
+    oleg.connect('emrpc://localhost:4000/') # connect to that address
+  end
+
+  # Output:
+  Pid #<EMRPC::RemotePid:0x143b740> connected to the user.
+  Pid #<HelloWorld:0x143d540> replied: Hello!
+
+-------------------------------------------------------------------------------
+

data/Rakefile

@@ -0,0 +1,156 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+require "spec/rake/spectask"
+require "fileutils"
+
+
+##############################################################################
+# Automated tests
+##############################################################################
+
+desc "Run specs"
+task :spec  => :'specs:spec'
+task :specs => :'specs:spec'
+
+namespace :specs do  
+  
+  def spec_path
+    path = ENV['SPECS_PATH'] || "spec"
+    puts "Using #{path.inspect} path. (See SPECS_PATH environment variable.)"
+    path
+  end
+  
+  desc "Run specs"
+  task :spec do
+    system("spec #{spec_path} -c")
+  end
+  
+  desc "Runs specs set by SPECS_PATH (default is 'spec') in a loop detecting random errors"
+  task :loop do
+    def run_spec_iteration(path = "spec", counter = 0)
+      r = `spec #{path}`
+      if r =~ /(\A|[.PFE])[FE]/ || r =~ /[FE]([.PFE]|\z)/
+        puts r
+        counter + 1
+      else 
+        counter
+      end
+    end
+    path = spec_path
+    iters = (ENV['SPECS_ITERS'] || 10_000).to_i
+    puts "#{iters} iterations. (See SPECS_ITERS environment variable.)"
+    fs = 0
+    iters.times do |i| 
+      puts "Iterations: #{i}   Failures: #{fs}"
+      fs = run_spec_iteration(path, fs)
+    end
+  end
+end
+
+
+##############################################################################
+# Packaging & Installation
+##############################################################################
+
+def __DIR__
+  File.dirname(__FILE__)
+end
+
+include FileUtils
+
+require "lib/emrpc/version"
+
+def sudo
+  ENV['EMRPC_SUDO'] ||= "sudo"
+  sudo = windows? ? "" : ENV['EMRPC_SUDO']
+end
+
+def windows?
+  (PLATFORM =~ /win32|cygwin/) rescue nil
+end
+
+def install_home
+  ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+end
+
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"]
+
+desc "Run the specs."
+task :default => :specs
+
+task :emrpc => [:clean, :rdoc, :package]
+
+RUBY_FORGE_PROJECT  = "emrpc"
+PROJECT_URL         = "http://oleganza.com/"
+PROJECT_SUMMARY     = "Efficient RPC library with evented and blocking APIs. In all ways better than DRb."
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
+AUTHOR = "Oleg Andreev"
+EMAIL  = "oleganza@gmail.com"
+
+GEM_NAME    = "emrpc"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = EMRPC::VERSION + PKG_BUILD
+
+RELEASE_NAME    = "REL #{GEM_VERSION}"
+
+require "extlib/tasks/release"
+
+spec = Gem::Specification.new do |s|
+  s.name         = GEM_NAME
+  s.version      = GEM_VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.author       = AUTHOR
+  s.email        = EMAIL
+  s.homepage     = PROJECT_URL
+  s.summary      = PROJECT_SUMMARY
+  s.bindir       = "bin"
+  s.description  = s.summary
+  s.executables  = %w( emrpc )
+  s.require_path = "lib"
+  s.files        = %w( README Rakefile TODO MIT-LICENSE ) + Dir["{docs,bin,spec,lib,examples,script}/**/*"]
+
+  # rdoc
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w( README TODO MIT-LICENSE )
+  #s.rdoc_options     += RDOC_OPTS + ["--exclude", "^(app|uploads)"]
+
+  # Dependencies
+  s.add_dependency "eventmachine"
+  s.add_dependency "rake"
+  s.add_dependency "rspec"
+  
+  # See sources on github.com/oleganza
+  s.add_dependency "gem_console"
+  
+  # Requirements
+  s.requirements << "You need to install the json (or json_pure), yaml, rack gems to use related features."
+  s.required_ruby_version = ">= 1.8.4"
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc "Generate *.gemspec file"
+task :gemspec do
+  gemspec = "spec = " + spec.to_ruby
+  path = File.join(File.expand_path(File.dirname(__FILE__)), "emrpc.gemspec")
+  puts %{Writing "#{path}"}
+  File.open(path, "w") do |f| 
+    f.write(gemspec)
+  end
+end
+
+desc "Run :package and install the resulting .gem"
+task :install => :package do
+  sh %{#{sudo} gem install #{install_home} --local pkg/#{GEM_NAME}-#{GEM_VERSION}.gem --no-rdoc --no-ri}
+end
+
+desc "Run :clean and uninstall the .gem"
+task :uninstall => :clean do
+  sh %{#{sudo} gem uninstall #{GEM_NAME}}
+end

data/TODO

@@ -0,0 +1,47 @@
+
+IMPROVEMENTS
+
+* Rev: 
+  * Rev::Server#on_connection: on_connect is called before @block.call: 
+    this is not how EM behaves. The order is crucial because we would like to 
+    pass some configuration with @block and use it inside on_connect/connection_completed callback.
+    TODO: suggest a patch to Toni Arciery.
+    
+  * lib/rev/loop.rb:60 typo: EVFLAG_NOENV should be used instead of EVFLAG_NOEV
+    TODO: suggest a patch to Toni Arciery.
+
+* When running $ spec spec/ servers sometimes are not unbinded and some specs fail.
+ * fixed issue with reconnecting pid.
+ * MultithreadedClient spec fails randomly with 0 timed out threads:
+    'EMRPC::MultithreadedClient with PoolTimeout should raise ThreadTimeout' FAILED
+    expected: > 10,
+         got:   0
+    /Users/olegandreev/Work/emrpc.git/spec/blocking_api/multithreaded_client_spec.rb:49:
+ * Transactions for MultithreadedClient to enable scheduling the same backend for all messages in a transaction.
+   This can be implemented in two ways:
+   1. Blocking: when transaction starts, backend is taken out of the queue while transaction is in process.
+   2. Non-blocking: backend can be rescheduled to other messages while transaction is in process,
+      but when it is needed again, system waits for that particular backend.
+      Non-blocking option might seem more efficient, but it also might be less safe: what if you really should
+      not interleave communication with the backend with foreign messages?
+   
+* SinglethreadedClient creates a messaging thread for each Pid. We should use some kind of 
+shared channel for a number of pids.
+* Try to use Thread.critical instead of Queue.new to achive better performance.
+
+FEATURES
+
+* filters for messages (erlang-like receive() pattern-matching)
+* passing particular objects through TCP
+* resource discovery
+* ring/chord protocol
+* rack http server & http client
+* Async DNS support
+* REv along with eventmachine backend
+
+TASKS
+
+* Documentation and examples!
+* Benchmark against DRb.
+* Publish gem somewhere.
+* Total world domination.

data/bin/emrpc

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'gem_console'
+gem_console('emrpc')

data/lib/emrpc.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'eventmachine'
+
+# add current dir to the load path
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__))))
+
+$DEBUG ||= ENV['DEBUG']
+
+require 'emrpc/version'
+require 'emrpc/util'
+require 'emrpc/protocols'
+require 'emrpc/evented_api'
+require 'emrpc/blocking_api'
+require 'emrpc/server'
+require 'emrpc/client'

data/lib/emrpc/archive/reference_savior.rb

@@ -0,0 +1,48 @@
+module EMRPC
+  
+  class StaleReference < StandardError; end
+  
+  class ReferenceSavior
+    attr_accessor :timeout
+    # :timeout - specifies a time interval for keeping a reference to a value
+    def initialize(options)
+      @timeout        = options[:timeout] || 60
+      @timer          = options[:timer] || Timers::EVENTED
+      @timeout_thread = @timer.call(@timeout, method(:swap_pages))
+      # We keep two previous pages to ensure, that the value lives for at least +timeout+ seconds.
+      @page1 = new_page
+      @page2 = new_page
+    end
+    
+    def set(val)
+      oid = val.object_id
+      ping(oid, val)
+      MethodProxy.new(Wrapper.new(oid))
+    end
+    
+    def get(oid)
+      oid = oid.to_i
+      val = @page1[oid] || @page2[oid]
+      raise StaleReference.new("Object id #{oid} was not found in a ReferenceSavior cache. It could have been garbage collected after #{@timeout} sec.") unless val
+      ping(oid, val)
+      val
+    end
+    
+    def ping(oid, val)
+      @page1[oid] = val
+    end
+    
+    # @page2 disappears and will be garbage collected.
+    # @page1 is copied to @page2 for another @timeout seconds
+    # and is replaced by a brand new cache page.
+    def swap_pages
+      @page2 = @page1
+      @page1 = new_page
+    end
+
+    def new_page
+      Hash.new
+    end
+  end
+end
+  

data/lib/emrpc/archive/ring.rb

@@ -0,0 +1,44 @@
+module EMRPC
+=begin
+
+  REPLICATION
+  
+    Who does replication?
+    
+    Master schedules replication streams:
+      + replication is centralized
+      - replicas' existance is not guaranteed.
+      - overcomplication (?)
+    Primary chunkserver replicates data to secondary chunkservers:
+      - every chunkserver must know about other chunkservers
+      - 
+    Client streams data to all the chunkservers:
+      - bandwidth!
+      + most simple scheme
+
+  RELIABILITY PRINCIPLES
+  
+  1. Client should be guaranteed, that data is completely replicated.
+    Therefore, it can do replication on its own.
+      For optimization reasons, it can delegate some streams to
+      other nodes. Say, it sends data to node A and tells it to replicate data
+      to node B. A must report finish of both A and B streamings.
+  2. Client may connect any node and try to upload the file there.
+
+=end
+
+  module Ring
+    
+    class Bucket
+      attr_accessor :range
+      def initialize
+        
+      end
+    end
+    
+    class Master
+      
+    end
+    
+  end
+end