rinterface 0.0.3

data/lib/rinterface/erlang/types.rb

@@ -0,0 +1,37 @@
+module Erlang
+  module External
+    module  Types
+      SMALL_INT = 97
+      INT = 98
+
+      SMALL_BIGNUM = 110
+      LARGE_BIGNUM = 111
+
+      FLOAT = 99
+      NEW_FLOAT = 70
+
+      ATOM = 100
+      REF = 101           #old style reference
+      NEW_REF = 114
+      PORT = 102          #not supported accross node boundaries
+      PID = 103
+
+      SMALL_TUPLE = 104
+      LARGE_TUPLE = 105
+
+      NIL = 106
+      STRING = 107
+      LIST = 108
+      BIN = 109
+
+      FUN = 117
+      NEW_FUN = 112
+    end
+
+    VERSION = 131
+
+    MAX_INT = (1 << 27) -1
+    MIN_INT = -(1 << 27)
+    MAX_ATOM = 255
+  end
+end

data/lib/rinterface/node.rb

@@ -0,0 +1,242 @@
+#
+# Single shot client.
+# - connects to epmd to get the port number of the erlang node
+# - does the handshake
+# - makes the RPC call
+#
+module Erlang
+  class Node
+    attr_reader :result
+
+    def initialize
+      @result = nil
+    end
+
+    class << self
+      def fun(node, mod, fun, *args)
+        rpc(node, mod, fun, args)
+      end
+
+      def rpc(node, mod, fun, args)
+        n = self.new
+        setup = proc{ n.do_connect(node, mod, fun, args) }
+
+        if EM.reactor_running?
+          setup.call
+        else
+          EM.run(&setup)
+        end
+        n.result
+      end
+      #alias :fun :rpc
+    end
+
+    def do_connect(node,mod,fun,args)
+      epmd = EpmdConnection.lookup_node(node)
+      epmd.callback do |port|
+        conn = NodeConnection.rpc_call(node,port,mod,fun,args) do |c|
+          c.destnode = node
+          c.mod = mod
+          c.fun = fun
+          c.args = args
+          c.port = port
+          c.myname = build_nodename
+          c.cookie = get_cookie
+        end
+        conn.callback do |r|
+          # Check for bad rpc response
+          # this is where I miss the patten matching in Erlang
+          if r.is_a?(Array)
+            if !r.empty? && r[0] == :badrpc
+              @result = [:badrpc,r[1]]
+            else
+              @result = [:ok,r]
+            end
+          else
+            @result = [:ok,r]
+          end
+          EM.stop
+        end
+        conn.errback do |err|
+          # never called??
+          @result = [:badrpc,err]
+          EM.stop
+        end
+      end
+      epmd.errback do |err|
+        # return bad RPC no port found (0)
+        @result = [:badrpc,"no port found for service"]
+        EM.stop
+      end
+    end
+
+  end
+
+
+  class NodeConnection < EM::Connection
+    include EM::Deferrable
+
+    attr_accessor :host,:myname,:destnode,:port,:cookie,:mod,:fun,:args
+
+    # node = destination node
+    # port = the port of the Erlang node (from epmd)
+    # mod  = the module to call
+    # fun  = the function to call
+    # args = args to pass to fun
+    def self.rpc_call(node,port,mod,fun,args)
+      EM.connect("127.0.0.1",port,self) do |c|
+        c.destnode = node
+        c.mod = mod
+        c.fun = fun
+        c.args = args
+        c.port = port
+        c.myname = build_nodename
+        c.cookie = get_cookie
+      end
+    end
+
+
+    # Get the Cookie from the home directory
+    def self.get_cookie
+      # ... I did it all for the cookie, come on the cookie ...
+      fp = File.expand_path("~#{ENV['USER']}/.erlang.cookie")
+      fh = File.open(fp,'r')
+      fh.readline.strip
+    end
+
+    # Build a nodename for us
+    def self.build_nodename
+      require 'socket'
+      myhostname = Socket.gethostname.split(".")[0]
+      "ruby_client@#{myhostname}"
+    end
+
+    def post_init
+      @responder = :determine_message
+    end
+
+    def connection_completed
+      send_data send_name
+    end
+
+    def receive_data data
+      @resp = data
+      send @responder
+    end
+
+    def handle_any_response
+      result = ""
+      decoder = Decode.read_bits(@resp)
+      s = decoder.read_4
+      #puts "Size: #{s}"
+      code = decoder.read_string(1)
+      if code == 'p'
+        #puts "found the p"
+        # read the control message and ignore
+        decoder.read_any
+        # read the message
+        result = decoder.read_any
+        #puts "Raw Response: #{result.inspect}"
+        set_deferred_success result[1]
+      else
+        # This seems to never happen...always 'p'
+        result = decoder.read_any
+        set_deferred_failure result
+      end
+    end
+
+    def send_name
+      full_host_name = self.myname
+      encode = Encoder.new
+      encode.write_2(full_host_name.length + 7)
+      # node type
+      encode.write_1(110)
+      # distChoose
+      encode.write_2(5)
+      # flags
+      encode.write_4(4|256|1024|2048)
+      # node name
+      encode.write_string(full_host_name)
+      encode.out.string
+    end
+
+    def determine_message
+      decoder = Decode.read_bits(@resp)
+      packet_size = decoder.read_2
+      #puts "PacketSize: #{packet_size}"
+      status_code = decoder.read_string(1)
+      case status_code
+      when 's' then receive_status(packet_size,decoder)
+      when 'n' then receive_challenge(packet_size,decoder)
+      when 'a' then receive_challenge_ack(packet_size,decoder)
+      else "Got back a weird packet"
+      end
+    end
+
+    def receive_status(packet_size,decoder)
+      status = decoder.read_string(packet_size-1)
+      if decoder.in.size > (packet_size + 2)
+        # Hack when both receive packets are crammed together into 1
+        next_packet_size = decoder.read_2 # read size
+        status_code = decoder.read_string(1)
+        receive_challenge(next_packet_size, decoder)
+      end
+      set_deferred_failure "Failed on Recv Status: #{status_code}" unless status == 'ok'
+    end
+
+    def receive_challenge(packet_size,decoder)
+      dist_code = decoder.read_2
+      #puts "Code: #{dist_code}"
+      flags = decoder.read_4
+      #puts "Flags #{flags}"
+      challenge = decoder.read_4
+      his_name = decoder.read_string(decoder.in.size-13)
+      #puts "His name: #{his_name}"
+      #puts "Got the challenge #{challenge}"
+      #out_challenge = make_challenge(challenge)
+      send_data make_challenge(challenge)
+    end
+
+    def make_challenge(her_challenge)
+      incr_digest = Digest::MD5.new()
+      incr_digest << @cookie
+      incr_digest << her_challenge.to_s
+      digest = incr_digest.digest
+      our_challenge = rand(10000)
+      encoder = Encoder.new
+      encoder.write_2(21)
+      encoder.write_string('r')
+      encoder.write_4(our_challenge)
+      encoder.write_string(digest)
+      encoder.out.string
+    end
+
+    # Handshake complete...send the RPC
+    def receive_challenge_ack(packet_size,decoder)
+      @responder = :handle_any_response
+      call_remote
+    end
+
+    def call_remote
+      myPid = Erlang::Terms::Pid.new(self.myname.intern,5,5,5)
+      call_tuple = [:call,self.mod.intern,self.fun.intern,Erlang::Terms::List.new(self.args),:user]
+      rpc_tuple  = [myPid,call_tuple]
+      ctl_msg = [6,myPid,self.cookie.intern,:rex]
+
+      encode_data = Encoder.new
+      encode_data.term_to_binary(ctl_msg)
+      encode_data.term_to_binary(rpc_tuple)
+      data = encode_data.out.string
+
+      f = Encoder.new
+      f.write_4(data.length + 1)
+      final_out = f.out.string + 'p' + data
+      send_data final_out
+    end
+
+  end
+end
+
+
+
+

data/lib/rinterface.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "rubygems"
+require "eventmachine"
+require "digest/md5"
+require "rinterface/erlang/external_format"
+require "rinterface/erlang/types"
+require "rinterface/erlang/encoder"
+require "rinterface/erlang/decoder"
+require "rinterface/epmd"
+require "rinterface/node"
+require "rinterface/erl"

data/rinterface.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rinterface}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dave Bryson", "\303\211verton Ribeiro", "Marcos Piccinini"]
+  s.date = %q{2010-03-31}
+  s.description = %q{Pure Ruby client that can send RPC calls to an Erlang node}
+  s.email = %q{r@interf.ace}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "examples/client.rb",
+     "examples/math_server.erl",
+     "lib/rinterface.rb",
+     "lib/rinterface/epmd.rb",
+     "lib/rinterface/erl.rb",
+     "lib/rinterface/erlang/decoder.rb",
+     "lib/rinterface/erlang/encoder.rb",
+     "lib/rinterface/erlang/external_format.rb",
+     "lib/rinterface/erlang/types.rb",
+     "lib/rinterface/node.rb",
+     "rinterface.gemspec",
+     "spec/rinterface/erl_spec.rb",
+     "spec/rinterface/erlang/external_format_spec.rb",
+     "spec/rinterface/node_spec.rb",
+     "spec/rinterface_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/spec_server.erl"
+  ]
+  s.homepage = %q{http://github.com/davebryson/rinterface}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Erlang RPC Ruby Client}
+  s.test_files = [
+    "spec/rinterface_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/rinterface/node_spec.rb",
+     "spec/rinterface/erl_spec.rb",
+     "spec/rinterface/erlang/external_format_spec.rb",
+     "examples/client.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/rinterface/erl_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+include Rinterface
+
+describe Erl do
+
+  it "should shotcut method calling" do
+    Erl::SpecServer.echo(:spec, "Rock").should eql([:ok, "Rock"])
+  end
+
+  it "should shotcut method calling" do
+    Erl::SpecServer.power(:spec, 10).should eql([:ok, 100])
+  end
+
+  it "should shotcut method calling" do
+    Erl::SpecServer.add(:spec, 2, 2).should be_ok_with(4)
+  end
+
+  it "should snake case" do
+    Erl.snake("SpecServer").should eql("spec_server")
+    Erl.snake("Fu").should eql("fu")
+  end
+
+end
+

data/spec/rinterface/erlang/external_format_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "Erlang Terms" do
+
+end

data/spec/rinterface/node_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Node" do
+
+end

data/spec/rinterface_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Rinterface" do
+
+  describe "Erlang Spec Server" do
+
+    it "should work with arity 1" do
+      r = Erlang::Node.fun("spec","spec_server","power", 10)
+      r.should eql([:ok, 100])
+    end
+
+    it "should sum" do
+      r = Erlang::Node.fun("spec","spec_server","add", 10, 10)
+      r.should eql([:ok, 20])
+    end
+
+    it "should work the old way" do
+      r = Erlang::Node.rpc("spec","spec_server","add", [10, 10])
+      r.should eql([:ok, 20])
+    end
+
+    it "should have a nice matcher" do
+      r = Erlang::Node.fun("spec","spec_server","add", 10, 20)
+      r.should be_ok
+    end
+
+    it "should have a nicer matcher" do
+      r = Erlang::Node.fun("spec","spec_server","add", 10, 20)
+      r.should be_ok_with(30)
+    end
+  end
+
+  describe "Numbers" do
+
+    it "should work small ints" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", 99)
+      r.should eql([:ok, 99])
+    end
+
+    it "should work with negative ints" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", -99)
+      r.should eql([:ok, -99])
+    end
+
+    it "should work small ints 8bits" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", 255)
+      r.should eql([:ok, 255])
+    end
+
+    it "should work medium ints +8bits" do
+      pending
+      r = Erlang::Node.fun("spec","spec_server", "echo", 255)
+      r.should eql([:ok, 256])
+    end
+
+    it "should work with floats" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", 0.005)
+      r.should eql([:ok, 0.005])
+      r[1].should be_instance_of(Float)
+    end
+
+    it "should work with negative floats" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", -0.5)
+      r.should eql([:ok, -0.5])
+      r[1].should be_instance_of(Float)
+    end
+
+    it "should work with floats" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", 1234.5)
+      r.should eql([:ok, 1234.5])
+    end
+
+    it "should work with floats" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", 1234.59999)
+      r.should eql([:ok, 1234.59999])
+    end
+
+  end
+
+  describe "Strings" do
+
+    it "should work with strings" do
+      r = Erlang::Node.fun("spec","spec_server", "dump", ["hi from ruby"])
+      r.should eql([:ok, :ok])
+    end
+
+    it "should work with strings" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", "ping")
+      r.should eql([:ok, "ping"])
+    end
+
+    it "should work with strange chars I" do
+      r = Erlang::Node.fun("spec","spec_server", "echo", "($)[&]{@}")
+      r.should be_ok_with("($)[&]{@}")
+    end
+
+
+  end
+
+  describe "Collections" do
+
+    it "should work with atoms {sqr, 10}" do
+      r = Erlang::Node.rpc("spec","spec_server","area", {:sqr => 10})
+      r.should be_ok_with(100)
+    end
+
+    it "should work with atoms and integers {circ, 10}" do
+      r = Erlang::Node.rpc("spec","spec_server","area", {:circ => 10})
+      r.should be_ok_with(314.159)
+    end
+
+    it "should work with atoms and floats {circ, 10.1}" do
+      r = Erlang::Node.rpc("spec","spec_server","area", {:circ => 10.1})
+      r.should be_ok_with(320.47359589999996)
+    end
+
+    it "should work with atoms {sqr, 10}" do
+      r = Erlang::Node.rpc("spec","spec_server","echo", {:sqr => 10})
+      r.should eql([:ok, [:sqr, 10]])
+    end
+
+    it "should work with arrays" do
+      r = Erlang::Node.fun("spec","spec_server","distance", [1,1], [2,2])
+      r.should be_ok_with(1.4142135623730951)
+    end
+
+    it "should return errors" do
+      r = Erlang::Node.fun("p","spec_server","add", 10, 20)
+      r.should_not be_ok
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rinterface'
+require 'spec'
+require 'spec/autorun'
+module RinterfaceMatchers
+  class BeOk
+
+    def initialize(expect=nil)
+      @expect = expect
+    end
+
+    def matches?(actual)
+      code, @actual = actual
+      cc = code == :ok
+      @expect ? (@actual == @expect && cc) : cc
+    end
+
+    def failure_message;          "expected #{@expect} but received #{@actual.inspect}";    end
+    def negative_failure_message; "expected something else then '#{@expect}' but got '#{@actual}'";    end
+  end
+
+  def be_ok;    BeOk.new;  end
+
+  def be_ok_with(v)
+    BeOk.new(v)
+  end
+end
+
+
+# Hack-ish
+module Daemon
+  NAME = "spec_server"
+  COMM = "erl -noshell -W -pa spec -sname spec -s #{NAME}&"
+
+  def self.start!
+    if is_running?
+      puts "Spec daemon running. (PID #{@pid})"
+    else
+      puts "Starting daemon.."
+      system("rake spec:run")#erl -noshell -W -pa spec -sname spec -s spec_server&")
+      sleep 1
+      start!
+    end
+  end
+
+  def self.is_running?
+    # Avoids grep from greping itself
+    n2, n1 = NAME[-1].chr, NAME.chop
+    if pid = `ps x | grep #{n1}[#{n2}]`.split(/\s/)[1]
+      @pid = pid.to_i
+    else
+      false
+    end
+  end
+end
+
+puts Daemon.start!
+
+Spec::Runner.configure do |config|
+  config.include RinterfaceMatchers
+end
+

data/spec/spec_server.erl

@@ -0,0 +1,29 @@
+-module(spec_server).
+-export([start/0, power/1, echo/1, dump/1, add/2, area/1, distance/2]).
+
+start()   -> ok.
+
+echo(R)  -> R.
+
+add(X, Y) -> X + Y.
+
+power(P)  -> P * P.
+
+dump(W)   -> io:format("Received ~p~n", [W]).
+
+area({sqr, S})    -> S * S;
+area({ret, W, H}) -> W * H;
+area({circ, R})   ->
+    io:format("Area received: ~p~n", [R]),
+    Result = 3.14159 * R * R,
+    io:format("Result ~p~n", [Result]),
+    Result.
+
+distance(P1, P2) ->
+    io:format("Distance received: ~p, ~p~n", [P1, P2]),
+    {X1, Y1} = P1,
+    {X2, Y2} = P2,
+    Result = math:sqrt(math:pow(X2 - X1, 2) + math:pow(Y2 - Y1, 2)),
+    io:format("Result: ~p~n", [Result]),
+    Result.
+