rinterface 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.cache
+*.beam
+*.dump
+*.gem

data/README.md

@@ -0,0 +1,111 @@
+rinterface
+==========
+
+Pure Ruby client that can send RPC calls to an Erlang node.
+_It's very much a work in progress._
+
+__License:__ MIT ?
+
+
+## Install
+
+    gem install rinterface
+
+
+## Try it out
+
+Open a terminal and run:
+
+    rake run
+
+This will start the erlang node named 'math'.
+
+Open another terminal, and run:
+
+    ruby examples/client.rb
+
+
+## How to use?
+
+In your Ruby code, make a call to the Erlang node like this:
+
+Erlang::Node(nodename,module,function,args) => [:ok,Response] | [:badprc,Reason]
+
+
+    r = Erlang::Node.rpc("math","math_server","add",[10,20])
+
+    if r[0] == :badrpc
+      puts "Got and Error. Reason #{r[1]}"
+    else
+      puts "Success: #{r[1]}"
+    end
+
+Where:
+
+*  math is the node name (the -sname of the Erlang node)
+*  math_server is the name of the module
+*  add is the funtion to call
+*  [10,20] is an array of arguments to pass to the function
+
+The result will always be an Array of the form:
+
+    [:ok, Response]
+
+Where Response is the result from the Erlang, or:
+
+    [:badrpc, Reason]
+
+Where Reason is the 'why' it failed.
+
+### Experimental new way
+
+The code above can be written like this now:
+
+    Erl::MathServer.add(10, 20)
+
+(Ain`t Ruby a beauty? ;)
+
+
+## So you wanna...
+
+### Test your Erlang code from RSpec...
+
+Here's a quick and simple example. Make sure you put the rinterface lib into RAILS_ROOT/lib and start the math_server in 'test'
+
+
+
+### Call Erlang from your Rails app...
+
+Here's a quick and simple example. Make sure you put the rinterface lib into RAILS_ROOT/lib and start the math_server in 'test'
+In the controller:
+
+    controllers/math_controller.rb
+
+    require "lib/rinterface"
+
+    class MathController < ApplicationController
+      def index
+        a = params[:a]
+        b = params[:b]
+        r = Erlang::Node.rpc("math","math_server","add",[a.to_i,b.to_i])
+
+        if r[0] == :badrpc
+          @result = "Error"
+        else
+          @result = r[1]
+        end
+      end
+    end
+
+
+Finally, add a template for the view, and try 'http://localhost:3000/math?a=2&b=3'.
+This is not ideal yet and not something I'd use yet in production,
+but it's a starting point for experimenting.
+
+
+## Specs
+
+Don`t forget to run specs before/after patching.
+
+Use either "rake spec" or "spec spec",
+it`ll start the erlang daemon automatically.

data/Rakefile

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+CLEAN   << FileList['**/*.dump']
+CLOBBER << FileList['**/*.beam']
+SRC  = FileList['**/*.erl']
+OBJ  = SRC.ext("beam") #)pathmap("%{examples,spec}X.beam")
+ERLC_FLAGS = "-Iinclude +warn_unused_vars +warn_unused_import"
+START_MODULE = "math_server"
+
+# Gem
+#
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rinterface"
+    gem.summary = "Erlang RPC Ruby Client"
+    gem.description = "Pure Ruby client that can send RPC calls to an Erlang node"
+    gem.email = "r@interf.ace"
+    gem.homepage = "http://github.com/davebryson/rinterface"
+    gem.authors = ["Dave Bryson", "Éverton Ribeiro", "Marcos Piccinini"]
+    gem.add_dependency "eventmachine"
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+# Compile
+#
+rule ".beam" =>  ".erl" do |t|
+  sh "erlc -o #{t.name.split("/")[0]} -W #{ERLC_FLAGS} #{t.source}"
+end
+
+desc "Compile all"
+task :compile =>  OBJ
+task :default => :compile
+
+# Shell
+#
+desc "Open up a shell"
+task :shell => [:compile] do
+  sh("erl -sname rinterface -pa examples")
+end
+
+namespace :daemon do
+  desc "Daemon run #{START_MODULE}:start()"
+  task :start => [:compile] do
+    pid = sh("erl -heart -W -pa examples -sname math -s #{START_MODULE} -detached")
+    puts "Now try 'ruby examples/client.rb' #{pid}"
+  end
+
+  task :status do
+    sh("ps aux | grep #{START_MODULE}")
+  end
+end
+
+namespace :spec do
+  desc "Open up a shell and run spec test server"
+  task :run => [:compile] do
+    sh("erl -noshell -W -pa spec -sname spec -s spec_server&")
+  end
+  desc "Open up a shell and run spec test server"
+  task :shell => [:compile] do
+    sh("erl -W -pa spec -sname spec -s spec_server")
+  end
+end
+
+task :test => [:compile] do
+  puts "Running suite.."
+  Rake::Task["spec"].invoke
+  Rake::Task["spec"].invoke
+end
+
+# Spec
+#
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+task :spec => :check_dependencies
+
+# RDoc
+#
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rinterface #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/examples/client.rb

@@ -0,0 +1,19 @@
+require 'lib/rinterface'
+
+
+# Try different responses...
+
+puts "Bad rpc test. Try to call the wrong service"
+r = Erlang::Node.rpc("math","matx_server","add",[10,20])
+puts "Got: #{r.inspect}"
+
+puts "--------"
+puts "Bad port test, No Port for Service. Can't find a port for 'ath'"
+r = Erlang::Node.rpc("ath","matx_server","add",[10,20])
+puts "Got: #{r.inspect}"
+
+puts "--------"
+puts "Good call, add 10 + 20"
+r = Erlang::Node.rpc("math","math_server","add",[10,20])
+puts "Got: #{r.inspect}"
+

data/examples/math_server.erl

@@ -0,0 +1,28 @@
+%%
+%% Simple add server
+%%
+-module(math_server).
+-export([start/0,add/2]).
+
+start() ->
+    register(?MODULE,spawn(fun() -> loop() end)).
+
+add(X,Y) ->
+    ?MODULE ! {self(),add,X,Y},
+    receive
+  {?MODULE,Response} -> Response
+    end.
+
+sum(X,Y) -> X+Y.
+
+loop() ->
+    receive
+  {From,add,X,Y} ->
+      error_logger:info_msg("Got the request, and doing the add...~n"),
+      Sum = X+Y,
+      From ! {?MODULE,Sum},
+      loop();
+  Any ->
+      error_logger:info_msg("Got a crazy msg: ~p~n",[Any]),
+      loop()
+    end.

data/lib/rinterface/epmd.rb

@@ -0,0 +1,58 @@
+#
+# Connects to epmd to find the port number of the requested node
+# this only implements port_please_request
+#
+module Erlang
+  class EpmdConnection < EM::Connection
+    include EM::Deferrable
+    attr_accessor :nodename
+
+    def self.lookup_node(nodename)
+      EM.connect("127.0.0.1",4369,self) do |conn|
+        conn.nodename = nodename
+      end
+    end
+
+    def connection_completed
+      send_data lookup_port
+    end
+
+    def receive_data(data)
+      parse_response(data)
+    end
+
+    def unbind
+    end
+
+    def lookup_port
+      out = StringIO.new('', 'w')
+
+      # Create the header with length: 2
+      out.write([@nodename.size + 1].pack('n'))
+
+      # Next the request
+      # tag. Length: 1
+      out.write([122].pack("C"))
+      # nodename
+      out.write(nodename)
+      out.string
+    end
+
+    # If we get a good result we only return
+    # the port (not reading all the information
+    def parse_response(input)
+      i = StringIO.new(input)
+      code = i.read(1).unpack('C').first
+      result = i.read(1).unpack('C').first
+      if result == 0
+        # good response read the port
+        port = i.read(2).unpack('n').first
+        set_deferred_success port
+      else
+        set_deferred_failure 0
+      end
+    end
+
+  end
+end
+

data/lib/rinterface/erl.rb

@@ -0,0 +1,24 @@
+module Rinterface
+
+  module Erl
+
+    class << self
+
+      def method_missing(fun, node, *rest)
+        Erlang::Node.fun(node.to_s, @@module, fun.to_s, *rest)
+      end
+
+      def const_missing(m)
+        @@module = snake(m)
+        self
+      end
+
+      def snake(txt)
+        txt.to_s.split(/(?=[A-Z])/).join('_').downcase
+      end
+
+    end
+
+  end
+
+end

data/lib/rinterface/erlang/decoder.rb

@@ -0,0 +1,223 @@
+module Erlang
+
+  class Decode
+    include External::Types
+
+    attr_accessor :in
+
+    def self.read_bits(string)
+      new(StringIO.new(string))
+    end
+
+    def self.read_any_from(string)
+      new(StringIO.new(string)).read_any
+    end
+
+    def initialize(ins)
+      @in = ins
+      @peeked = ""
+    end
+
+    def read_any
+      raise "Bad Math on Version" unless read_1 == External::VERSION
+      read_any_raw
+    end
+
+    def read_any_raw
+      case peek_1
+      when ATOM then read_atom
+      when SMALL_INT then read_small_int
+      when INT then read_int
+      when SMALL_BIGNUM then read_small_bignum
+      when LARGE_BIGNUM then read_large_bignum
+      when NEW_FLOAT then read_double
+      when FLOAT then read_float
+      when NEW_REF then read_new_reference
+      when PID then read_pid
+      when SMALL_TUPLE then read_small_tuple
+      when LARGE_TUPLE then read_large_tuple
+      when NIL then read_nil
+      when STRING then read_erl_string
+      when LIST then read_list
+      when BIN then read_bin
+      else
+        fail("Unknown term tag: #{peek_1}")
+      end
+    end
+
+    def read(length)
+      # p @peeked
+      if length < @peeked.length
+        result = @peeked[0...length]
+        @peeked = @peeked[length..-1]
+        length = 0
+      else
+        result = @peeked
+        @peeked = ''
+        length -= result.length
+      end
+
+      if length > 0
+        result << @in.read(length)
+      end
+      result
+    end
+
+    def peek(length)
+      if length <= @peeked.length
+        @peeked[0...length]
+      else
+        read_bytes = @in.read(length - @peeked.length)
+        @peeked << read_bytes if read_bytes
+        @peeked
+      end
+    end
+
+    def peek_1
+      peek(1).unpack("C").first
+    end
+
+    def peek_2
+      peek(2).unpack("n").first
+    end
+
+    def read_1
+      read(1).unpack("C").first
+    end
+
+    def read_2
+      read(2).unpack("n").first
+    end
+
+    def read_4
+      read(4).unpack("N").first
+    end
+
+    def read_string(length)
+      read(length)
+    end
+
+    def read_atom
+      fail("Invalid Type, not an atom") unless read_1 == ATOM
+      length = read_2
+      if length == 0
+        ''
+      else
+        read_string(length).to_sym
+      end
+    end
+
+    def read_small_int
+      fail("Invalid Type, not a small int") unless read_1 == SMALL_INT
+      read_1
+    end
+
+    def read_int
+      fail("Invalid Type, not an int") unless read_1 == INT
+      value = read_4
+      negative = (value >> 31)[0] == 1
+      value = (value - (1 << 32)) if negative
+      value = Fixnum.induced_from(value)
+    end
+
+    def read_small_bignum
+      fail("Invalid Type, not a small bignum") unless read_1 == SMALL_BIGNUM
+      size = read_1
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      Bignum.induced_from(added)
+    end
+
+    def read_large_bignum
+      fail("Invalid Type, not a large bignum") unless read_1 == LARGE_BIGNUM
+      size = read_4
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      Bignum.induced_from(added)
+    end
+
+    def read_double
+      fail("Invalid Type, not a double") unless read_1 == NEW_FLOAT
+      read_string(64).unpack('G').first
+    end
+
+    def read_float
+      fail("Invalid Type, not a float") unless read_1 == FLOAT
+
+      read_string(32).unpack('g').first
+    end
+
+    def read_new_reference
+      fail("Invalid Type, not a new-style reference") unless read_1 == NEW_REF
+      size = read_2
+      node = read_atom
+      creation = read_1
+      id = (0...size).map{|i| read_4 }
+      NewReference.new(node, creation, id)
+    end
+
+    def read_pid
+      fail("Invalid Type, not a pid") unless read_1 == PID
+      node = read_atom
+      id = read_4
+      serial = read_4
+      creation = read_1
+      Terms::Pid.new(node, id, serial, creation)
+    end
+
+    def read_small_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == SMALL_TUPLE
+      arity = read_1
+
+      (0...arity).map{|i| read_any_raw }
+    end
+
+    def read_large_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == LARGE_TUPLE
+      arity = read_4
+      (0...arity).map{|i| read_any_raw}
+    end
+
+    def read_nil
+      fail("Invalid Type, not a nil list") unless read_1 == NIL
+      []
+    end
+
+    def read_erl_string
+      fail("Invalid Type, not an erlang string") unless read_1 == STRING
+      length = read_2
+      read_string(length).unpack('C' * length)
+    end
+
+    def read_list
+      fail("Invalid Type, not an erlang list") unless read_1 == LIST
+      length = read_4
+      list = (0...length).map{|i| read_any_raw}
+      read_1
+      list
+    end
+
+    def read_bin
+      fail("Invalid Type, not an erlang binary") unless read_1 == BIN
+      length = read_4
+      read_string(length)
+    end
+
+    class DecodeError < StandardError;    end
+    def fail(str)
+      raise DecodeError, str
+    end
+
+  end
+
+end

data/lib/rinterface/erlang/encoder.rb

@@ -0,0 +1,107 @@
+module Erlang
+  class Encoder
+    include External::Types
+    include Terms
+
+    attr_accessor :out
+    def initialize
+      @out = StringIO.new('', 'w')
+    end
+
+    def rewind
+      @out.rewind
+    end
+
+    def term_to_binary obj
+      write_1 External::VERSION
+      write_any_raw obj
+    end
+
+    def write_any_raw obj
+      case obj
+      when Symbol then write_symbol(obj)
+      when Fixnum, Bignum then write_integer(obj)
+      when Float then write_double(obj)
+      when Array then write_tuple(obj)
+      when String then write_binary(obj)
+      when Pid then write_pid(obj)
+      when List then write_list(obj)
+      else
+        raise "Failed encoding!"
+      end
+    end
+
+    def write_1(byte)
+      @out.write([byte].pack("C"))
+    end
+
+    def write_2(short)
+      @out.write([short].pack("n"))
+    end
+
+    def write_4(long)
+      @out.write([long].pack("N"))
+    end
+
+    def write_string(string)
+      @out.write(string)
+    end
+
+    def write_symbol(sym)
+      data = sym.to_s
+      write_1 ATOM
+      write_2 data.length
+      write_string data
+    end
+
+    # TODO: Bignum support
+    def write_integer(num)
+      if 0 <= num && num < 256
+        write_1 SMALL_INT
+        write_1 num
+      else
+        write_1 INT
+        write_4 num
+      end
+    end
+
+    def write_double(num)
+      write_1 NEW_FLOAT
+      @out.write([num].pack('G'))
+    end
+
+    def write_tuple(data)
+      if data.length < 256
+        write_1 SMALL_TUPLE
+        write_1 data.length
+      else
+        write_1 LARGE_TUPLE
+        write_4 data.length
+      end
+      data.each{|e| write_any_raw e }
+    end
+
+    def write_pid(pid)
+      write_1(103)
+      write_symbol(pid.node)
+      write_4((pid.node_id & 0x7fff))
+      write_4((pid.serial & 0x1fff))
+      write_1((pid.creation & 0x3))
+    end
+
+    def write_list(list)
+      len = list.data.size
+      write_1(108)
+      write_4(len)
+      list.data.each{ |i| write_any_raw i }
+      write_1(106)
+    end
+
+    def write_binary(data)
+      write_1 BIN
+      write_4 data.length
+      write_string data
+    end
+
+  end
+end

data/lib/rinterface/erlang/external_format.rb

@@ -0,0 +1,28 @@
+#
+# adopted from Erlectricity
+# this version is slightly tweaked,  a bit sloppy, and needs a cleanin'
+#
+module Erlang
+  module Terms
+
+    class Pid
+      attr_reader :node, :node_id, :serial, :creation
+      def initialize(node,nid,serial,created)
+        @node = node
+        @node_id = nid
+        @serial = serial
+        @creation = created
+      end
+    end
+
+    class List
+      attr_reader :data
+      def initialize(array)
+        @data = array
+      end
+    end
+
+  end
+
+
+end