drbarpg 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 904cd118d012de004d15e6c521f20fa962cad506
+  data.tar.gz: c4f985153e0ffd0c63362d3eebe4c5c8e168ee84
+SHA512:
+  metadata.gz: 06d4ffe76e5ab4baef966ea23f12fb3b077fdf4e90eb7d746f498c28b437a28b953aeb45312c9c692ce067e19981f092ab44a8263b0b43003cda4fa9fb108fec
+  data.tar.gz: 578100b75206eb8ae4af1daa1a244824ae4af968f00b76d368be1fda9c98cd3d2f3e861edf21ec7bdcad1439770bcdad5cfdf190c4db31fb1c34565daabb7893

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Lars Kanis <lars@greiz-reinsdorf.de>
+
+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.rdoc

@@ -0,0 +1,64 @@
+= drbarpg
+{<img src="https://travis-ci.org/larskanis/drbarpg.png?branch=master" alt="Build Status" />}[https://travis-ci.org/larskanis/drbarpg]
+
+A protocol implementation for Distributed Ruby (DRb), supporting connections
+via a PostgreSQL server by using the LISTEN/NOTIFY event system.
+
+This project rocks and uses MIT-LICENSE.
+
+== Usage
+Add to your +Gemfile+ :
+  gem 'drbarpg'
+
+Run
+  $ bundle install
+  $ rake drbarpg:install:migrations
+  $ rake db:migrate
+
+Ensure the value of +pool+ in your +config/database.yml+ is high enough (at least 10).
+
+=== Example server
+  # Startup Rails environment
+  require 'config/environment'
+
+  # start up the DRb service
+  DRb.start_service "drbarpg://myserver", []
+
+  # wait for the DRb service to finish before exiting
+  DRb.thread.join
+
+=== Example client:
+  require 'config/environment'
+
+  # Start a local DRbServer to handle callbacks.
+  #
+  # Not necessary for this small example, but will be required
+  # as soon as we pass a non-marshallable object as an argument
+  # to a dRuby call.
+  DRb.start_service "drbarpg://"
+
+  # attach to the DRb server via the server URI
+  remote_array = DRbObject.new_with_uri("drbarpg://myserver")
+
+  p remote_array.size  # => 0
+
+  remote_array << 1
+
+  p remote_array.size  # => 1
+
+== Description
+
+drbarpg makes it possible to create DRb-connections via the connection to a PostgreSQL server.
+It easily integrates into rails projects and uses the configured database connection for
+inter process communication.
+
+Method calls with a size of less than 8000 bytes for all serialized parameters are directly
+passed through by the NOTIFY payload. This bypasses the transaction overhead in the database,
+so the calls are reasonably fast (approximately 1.5 of the time of a direct DRb-TCP connection).
+Calls with bigger parameter size are transferred by INSERT/SELECT and require transaction
+commits, so they usually take several milliseconds.
+
+== Requirements
+
+* PostgreSQL 9.0+
+* Rails 3.0+

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Drbarpg'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/models/drbarpg/message.rb

@@ -0,0 +1,4 @@
+module Drbarpg
+  class Message < ActiveRecord::Base
+  end
+end

data/db/migrate/20130531211747_create_drbarpg_drbarpg_messages.rb

@@ -0,0 +1,8 @@
+class CreateDrbarpgDrbarpgMessages < ActiveRecord::Migration
+  def change
+    create_table :drbarpg_messages do |t|
+      t.references "drbarpg_connection"
+      t.text "payload"
+    end
+  end
+end

data/db/migrate/20130601144555_create_drbarpg_drbarpg_connections.rb

@@ -0,0 +1,8 @@
+class CreateDrbarpgDrbarpgConnections < ActiveRecord::Migration
+  def change
+    create_table :drbarpg_connections do |t|
+      t.text "listen_channel"
+    end
+    add_index :drbarpg_connections, "listen_channel", :unique => true
+  end
+end

data/lib/drb/ar_pg.rb

@@ -0,0 +1,183 @@
+require 'drb/drb'
+require 'stringio'
+
+module DRb
+
+  # Implements DRb over an ActiveRecord connection to a PostgreSQL server
+  #
+  # DRb PostgreSQL socket URIs look like <code>drbarpg:?<option></code>.  The
+  # option is optional.
+
+  class DRbArPg
+    attr_reader :uri
+
+    def self.open(uri, config)
+      server_channel, = parse_uri(uri)
+
+      self.new(uri, nil, server_channel, :master, config)
+    end
+
+    def self.open_server(uri, config)
+      channel, = parse_uri(uri)
+      self.new(uri, channel, nil, :server, config)
+    end
+
+    def accept
+      @pgconn.wait_for_notify do |channel, pid, payload|
+        return self.class.new(nil, nil, payload, :slave, @config)
+      end
+    end
+
+    def self.uri_option(uri, config)
+      channel, option = parse_uri(uri)
+      return "drbarpg://#{channel}", option
+    end
+
+    def initialize(uri, listen_channel, notify_connection_id, act_as, config={})
+      @notify_connection_id = notify_connection_id
+      @config = config
+      @msg = DRbMessage.new(@config)
+      @conn = Drbarpg::Message.connection_pool.checkout
+      @pgconn = @conn.raw_connection
+
+      @listen_connection_id = @conn.exec_query("SELECT nextval('drbarpg_connections_id_seq') AS seq").first['seq']
+      @listen_channel = if listen_channel.nil? || listen_channel.empty?
+        @conn.quote_table_name("drbarpg__#{@listen_connection_id}")
+      else
+        @conn.quote_table_name("drbarpg_#{listen_channel}")
+      end
+
+      @conn.execute("LISTEN #{@listen_channel}");
+
+      case act_as
+      when :server
+        # Save the connection to the database to ensure that only one server can listen
+        # on a given channel.
+        @conn.exec_insert('INSERT INTO drbarpg_connections (id, listen_channel)
+                          VALUES ($1::int, $2::text)', nil,
+                          [[nil, @listen_connection_id], [nil, @listen_channel]])
+
+        uri_channel, uri_option = self.class.parse_uri(uri) if uri
+        uri = "drbarpg://_#{@listen_connection_id}?#{uri_option}" if uri_channel.nil? || uri_channel.empty?
+        @uri = uri
+      when :master
+        # connect to server channel
+        @conn.exec_update("NOTIFY #{@conn.quote_table_name("drbarpg_#{@notify_connection_id}")}, #{@conn.quote(@listen_connection_id)}");
+        # wait for acknowledgement with peer channel
+        @pgconn.wait_for_notify do |channel, pid, payload|
+          @notify_connection_id = payload
+          @notify_channel = @conn.quote_table_name("drbarpg__#{@notify_connection_id}")
+        end
+      when :slave
+        @notify_channel = @conn.quote_table_name("drbarpg__#{@notify_connection_id}")
+        # acknowledge with peer channel
+        @conn.exec_update("NOTIFY #{@notify_channel}, #{@conn.quote(@listen_connection_id)}");
+      end
+    end
+
+    def close
+      if @conn
+        if @notify_channel
+          @conn.exec_update("NOTIFY #{@notify_channel}, 'c'");
+        end
+        @conn.execute("UNLISTEN #{@listen_channel}");
+        @conn.exec_delete('DELETE FROM drbarpg_connections WHERE id=$1::int', nil, [[nil, @listen_connection_id]])
+        Drbarpg::Message.connection_pool.checkin(@conn)
+        @conn = @pgconn = nil
+      end
+    end
+
+    def alive?
+      @pgconn.consume_input
+      if (n=@pgconn.notifies)
+        if n[:extra] == 'c'
+          close
+        else
+          raise DRbConnError, "received unexpected notification"
+        end
+      end
+      !!@conn
+    end
+
+    def send_request(ref, msg_id, *arg, &b)
+      stream = StringIO.new
+      @msg.send_request(stream, ref, msg_id, *arg, &b)
+      send_message(stream.string)
+    end
+
+    def recv_reply
+      stream = StringIO.new(wait_for_message)
+      return @msg.recv_reply(stream)
+    end
+
+    def recv_request
+      begin
+        stream = StringIO.new(wait_for_message)
+        return @msg.recv_request(stream)
+      rescue
+        close
+        raise $!
+      end
+    end
+
+    def send_reply(succ, result)
+      begin
+        stream = StringIO.new
+        @msg.send_reply(stream, succ, result)
+        send_message(stream.string)
+      rescue
+        close
+        raise $!
+      end
+    end
+
+    private
+    def send_message(payload)
+      payload_b64 = [payload].pack('m')
+      if payload_b64.length >= 8000
+        @conn.exec_insert('INSERT INTO drbarpg_messages (drbarpg_connection_id, payload)
+                          VALUES ($1::int, $2::text)', nil, [[nil, @notify_connection_id], [nil, payload_b64]])
+        @conn.exec_update("NOTIFY #{@notify_channel}");
+      else
+        @conn.exec_update("NOTIFY #{@notify_channel}, '#{payload_b64}'");
+      end
+    end
+
+    def check_pending_message
+      row = @conn.exec_query('SELECT id, payload FROM drbarpg_messages WHERE drbarpg_connection_id=$1::int LIMIT 1',
+                        nil, [ [nil, @listen_connection_id] ]).first
+      if row
+        @conn.exec_delete('DELETE FROM drbarpg_messages WHERE id=$1::int', nil, [[nil, row['id']]])
+        return row['payload'].unpack('m')[0]
+      else
+        raise DRbConnError, "no message received"
+      end
+    end
+
+    def wait_for_message()
+      @pgconn.wait_for_notify do |channel, pid, payload|
+        if payload=='c'
+          close
+          return ''
+        elsif payload
+          return payload.unpack('m')[0]
+        else
+          return check_pending_message
+        end
+      end
+    end
+
+    def self.parse_uri(uri)
+      if /^drbarpg:\/\/(.*?)(\?(.*))?$/ =~ uri
+        channel = $1
+        option = $3
+        [channel, option]
+      else
+        raise(DRbBadScheme, uri) unless uri =~ /^drbarpg:/
+        raise(DRbBadURI, 'can\'t parse uri:' + uri)
+      end
+    end
+  end
+
+  DRbProtocol.add_protocol(DRbArPg)
+end

data/lib/drbarpg/engine.rb

@@ -0,0 +1,5 @@
+module Drbarpg
+  class Engine < ::Rails::Engine
+    isolate_namespace Drbarpg
+  end
+end

data/lib/drbarpg/version.rb

@@ -0,0 +1,3 @@
+module Drbarpg
+  VERSION = "0.0.1"
+end

data/lib/drbarpg.rb

@@ -0,0 +1,5 @@
+require 'drbarpg/engine'
+require 'drb/ar_pg'
+
+module Drbarpg
+end

data/test/drbarpg_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+require 'drb/ar_pg'
+require 'logger'
+require 'rbconfig'
+
+class DrbarpgTest < ActiveSupport::TestCase
+  self.use_transactional_fixtures = false
+
+  attr_reader :drb
+
+  UriServer = "drbarpg://server"
+  UriCallback = "drbarpg://"
+#   UriServer = "druby://localhost:33333"
+#   UriCallback = nil
+
+  def setup
+#     ActiveRecord::Base.logger = Logger.new STDERR
+
+    # Start forked server process
+#     ActiveRecord::Base.connection_pool.disconnect!
+#     rd, wr = IO.pipe
+#     fork do
+#       DRb.start_service(UriServer, Kernel)
+#       wr.puts "started"
+#       DRb.thread.join
+#     end
+
+    rd = IO.popen(RbConfig::CONFIG['ruby_install_name'], 'w+')
+    rd.write <<-EOT
+      $: << #{File.expand_path('..', __FILE__).inspect}
+      require 'test_helper'
+      require 'drb/ar_pg'
+
+#       ActiveRecord::Base.logger = Logger.new $stderr
+      DRb.start_service(#{UriServer.inspect}, Kernel)
+      $stdout.puts "started"
+      $stdout.flush
+      $stdout.reopen($stderr)
+      DRb.thread.join
+    EOT
+    rd.close_write
+
+    # Start local server for callbacks
+    DRb.start_service(UriCallback)
+
+    # Wait until server process has started
+    rd.gets
+
+    # Connect to server object
+    @drb = DRbObject.new_with_uri(UriServer)
+  end
+
+  def teardown
+    drb.eval("DRb.stop_service")
+    # Wait until server process has stopped
+    Process.wait
+    DRb.stop_service
+  end
+
+  test "allows two-way communication" do
+    remote_hash = drb.eval("@a = {}.extend(DRb::DRbUndumped)")
+
+    # Set local Proc in remote hash, re-fetch it and call it. Works without two-way comms
+    remote_hash["a"] = lambda { return 1 }
+    assert_equal 1, drb.eval("@a['a']").call
+
+    # Call same Proc in a remote context. This means establishing a connection to the local side, since
+    # the Proc is really a DRbObject on the remote side.
+    assert_equal 1, drb.eval("@a['a'].call")
+  end
+
+  test "allows big params" do
+    remote_hash = drb.eval("@a = {}.extend(DRb::DRbUndumped)")
+
+    remote_hash["a"] = "b"*8000
+    assert_equal "b"*8000, drb.eval("@a['a']")
+  end
+
+  test "runs reasonable fast" do
+    2000.times do
+      drb.rand
+    end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/test/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/test/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/test/dummy/config/application.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require(*Rails.groups)
+require "drbarpg"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+  end
+end
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)

data/test/dummy/config/database.yml

@@ -0,0 +1,60 @@
+# PostgreSQL. Versions 8.2 and up are supported.
+#
+# Install the pg driver:
+#   gem install pg
+# On OS X with Homebrew:
+#   gem install pg -- --with-pg-config=/usr/local/bin/pg_config
+# On OS X with MacPorts:
+#   gem install pg -- --with-pg-config=/opt/local/lib/postgresql84/bin/pg_config
+# On Windows:
+#   gem install pg
+#       Choose the win32 build.
+#       Install PostgreSQL and put its /bin directory on your path.
+#
+# Configure Using Gemfile
+# gem 'pg'
+#
+development:
+  adapter: postgresql
+  encoding: unicode
+  database: drbarpg_development
+  pool: 50
+#   username: drbarpg
+#   password:
+
+  # Connect on a TCP socket. Omitted by default since the client uses a
+  # domain socket that doesn't need configuration. Windows does not have
+  # domain sockets, so uncomment these lines.
+  #host: localhost
+
+  # The TCP port the server listens on. Defaults to 5432.
+  # If your server runs on a different port number, change accordingly.
+  #port: 5432
+
+  # Schema search path. The server defaults to $user,public
+  #schema_search_path: myapp,sharedapp,public
+
+  # Minimum log levels, in increasing order:
+  #   debug5, debug4, debug3, debug2, debug1,
+  #   log, notice, warning, error, fatal, and panic
+  # Defaults to warning.
+  #min_messages: notice
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: drbarpg_test
+  pool: 50
+#   username: drbarpg
+#   password:
+
+production:
+  adapter: postgresql
+  encoding: unicode
+  database: drbarpg_production
+  pool: 50
+#   username: drbarpg
+#   password:

data/test/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application.
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application.
+Dummy::Application.initialize!

data/test/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Rails.application

data/test/dummy/db/schema.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20130601144555) do
+
+  create_table "drbarpg_connections", :force => true do |t|
+    t.text "listen_channel"
+  end
+
+  add_index "drbarpg_connections", ["listen_channel"], :name => "index_drbarpg_connections_on_listen_channel", :unique => true
+
+  create_table "drbarpg_messages", :force => true do |t|
+    t.integer "drbarpg_connection_id"
+    t.text    "payload"
+  end
+
+end