msgpack-rpc 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

data/README

@@ -0,0 +1,29 @@
+
+= MessagePack-RPC
+
+
+== Description
+
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install msgpack-rpc
+
+
+== Features/Problems
+
+
+== Synopsis
+
+
+== Copyright
+
+Author::    frsyuki <frsyuki@users.sourceforge.jp>
+Copyright:: Copyright (c) 2009 frsyuki
+License::   Apache License, Version 2.0

data/Rakefile

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/contrib/sshpublisher'
+require 'fileutils'
+include FileUtils
+
+NAME              = "msgpack-rpc"
+AUTHOR            = "FURUHASHI Sadayuki"
+EMAIL             = "frsyuki _at_ users.sourceforge.jp"
+DESCRIPTION       = "RPC library using MessagePack, a ainary-based efficient data interchange format."
+RUBYFORGE_PROJECT = "msgpack"
+HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+BIN_FILES         = %w(  )
+VERS              = "0.1.0"
+
+#REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+REV = nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README",
+	"--inline-source",
+]
+
+task :default => [:test]
+task :package => [:clean]
+
+Rake::TestTask.new("test") do |t|
+	t.libs   << "test"
+	t.pattern = "test/**/*_test.rb"
+	t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	#s.has_rdoc          = true
+	s.extra_rdoc_files  = ["README", "ChangeLog", "AUTHORS"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPATH
+	s.executables       = BIN_FILES
+	s.rubyforge_project = RUBYFORGE_PROJECT
+	s.bindir            = "bin"
+	s.require_path      = "lib"
+	s.test_files        = Dir["test/test_*.rb"]
+
+  s.add_dependency "msgpack", ">= 0.3.1"
+  s.add_dependency "rev", ">= 0.3.0"
+	#s.required_ruby_version = '>= 1.8.2'
+
+	s.files = %w(README ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{sudo gem uninstall #{NAME}}
+end
+
+
+#Rake::RDocTask.new do |rdoc|
+#	rdoc.rdoc_dir = 'html'
+#	rdoc.options += RDOC_OPTS
+#	rdoc.template = "resh"
+#	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+#	if ENV['DOC_FILES']
+#		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+#	else
+#		rdoc.rdoc_files.include('README', 'ChangeLog')
+#		rdoc.rdoc_files.include('lib/**/*.rb')
+#		rdoc.rdoc_files.include('ext/**/*.c')
+#	end
+#end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+	require 'rubyforge'
+	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'frsyuki').upload
+end
+
+desc 'Package and upload the release to rubyforge.'
+task :release => [:clean, :package] do |t|
+	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
+	pkg = "pkg/#{NAME}-#{VERS}"
+
+	rf = RubyForge.new
+	puts "Logging in"
+	rf.login
+
+	c = rf.userconfig
+#	c["release_notes"] = description if description
+#	c["release_changes"] = changes if changes
+	c["preformatted"] = true
+
+	files = [
+		"#{pkg}.tgz",
+		"#{pkg}.gem"
+	].compact
+
+	puts "Releasing #{NAME} v. #{VERS}"
+	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
+end

data/lib/msgpack/rpc.rb

@@ -0,0 +1,436 @@
+#
+# MessagePack RPC for Ruby
+#
+# Copyright (C) 2009 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require 'msgpack'
+require 'rev'
+
+module MessagePack
+module RPC
+
+
+class Error < StandardError
+end
+
+class RPCError < Error
+	def initialize(msg)
+		super(msg)
+	end
+end
+
+class RemoteError < RPCError
+	def initialize(msg, result = nil)
+		super(msg)
+		@result = result
+	end
+	attr_reader :result
+end
+
+class TimeoutError < Error
+	def initialize
+		super("request timed out")
+	end
+end
+
+
+class Responder
+	def initialize(socket, msgid)
+		@socket = socket
+		@msgid = msgid
+	end
+
+	def result(retval, err = nil)
+		@socket.send_response(@msgid, retval, err)
+	end
+
+	def error(err)
+		result(nil, err)
+	end
+end
+
+
+REQUEST  = 0
+RESPONSE = 1
+NOTIFY   = 2
+
+
+module RPCSocket
+	def session=(s)
+		@session = s
+		s.add_socket(self)
+	end
+
+	def on_message(msg)
+		if msg[0] == REQUEST
+			on_request(msg[1], msg[2], msg[3])
+		elsif msg[0] == RESPONSE
+			on_response(msg[1], msg[3], msg[2])
+		elsif msg[0] == REQUEST
+			on_notify(msg[1], msg[2])
+		else
+			raise RPCError.new("unknown message type #{msg[0]}")
+		end
+	end
+
+	def on_close
+		return unless @session
+		@session.on_close(self)
+		@session = nil
+	rescue
+		nil
+	end
+
+	def on_request(msgid, method, param)
+		return unless @session
+		@session.on_request(method, param, Responder.new(self,msgid))
+	end
+
+	def on_notify(method, param)
+		return unless @session
+		@session.on_notify(method, param)
+	end
+
+	def on_response(msgid, res, err)
+		return unless @session
+		@session.on_response(msgid, res, err)
+	end
+
+	def send_request(msgid, method, param)
+		send_message [REQUEST, msgid, method, param]
+	end
+
+	def send_response(msgid, retval, err)
+		send_message [RESPONSE, msgid, err, retval]
+	end
+
+	def send_notify(method, param)
+		send_message [NOTIFY, method, param]
+	end
+end
+
+
+class RevSocket < ::Rev::TCPSocket
+	include RPCSocket
+
+	def initialize(*args)
+		@buffer = ''
+		@nread = 0
+		@mpac = MessagePack::Unpacker.new
+		super
+	end
+
+	def on_read(data)
+		@buffer << data
+
+		while true
+			@nread = @mpac.execute(@buffer, @nread)
+
+			if @mpac.finished?
+				msg = @mpac.data
+
+				@mpac.reset
+				@buffer.slice!(0, @nread)
+				@nread = 0
+
+				on_message(msg)  # RPCSocket#on_message
+
+				next unless @buffer.empty?
+			end
+
+			break
+		end
+	end
+
+	def send_message(msg)
+		write msg.to_msgpack
+	end
+end
+
+
+class ClientSession
+
+	class BasicRequest
+		def initialize(session, loop)
+			@error  = nil
+			@result = nil
+			@session = session
+			@timeout = session.timeout
+			@loop = loop
+		end
+		attr_reader :loop
+		attr_accessor :result, :error
+
+		def call(err, res)
+			@error  = err
+			@result = res
+			@session = nil
+		end
+
+		def join
+			while @session
+				@loop.run_once
+			end
+			self
+		end
+
+		def step_timeout
+			if @timeout < 1
+				true
+			else
+				@timeout -= 1
+				false
+			end
+		end
+	end
+
+
+	def initialize(loop)
+		@sock = nil
+		@reqtable = {}
+		@seqid = 0
+		@loop = loop
+		@timeout = 60    # FIXME default timeout time
+	end
+	attr_accessor :timeout
+
+	def add_socket(sock)
+		@sock = sock
+	end
+
+	def send(method, *args)
+		send_real(method, args, BasicRequest.new(self,@loop))
+	end
+
+	def callback(method, *args, &block)
+		send_real(method, args, block)
+	end
+
+	def call(method, *args)
+		req = send(method, *args)
+		req.join
+		if req.error
+			raise TimeoutError.new if req.error == :TimeoutError
+			raise RemoteError.new(req.error, req.result)
+		end
+		req.result
+	end
+
+	def notify(method, *args)
+		notify_real(method, args)
+	end
+
+
+	def on_response(msgid, result, error)
+		if req = @reqtable.delete(msgid)
+			req.call error, result
+		end
+	end
+
+	def on_notify(method, param)
+		raise RPCError.new("unexpected notify message")
+	end
+
+	def on_request(method, param, res)
+		raise RPCError.new("unexpected request message")
+	end
+
+	def on_close(sock)
+		@sock = nil
+	end
+
+	def close
+		@sock.close if @sock
+	end
+
+
+	def step_timeout
+		reqs = []
+		@reqtable.reject! {|msgid, req|
+			if req.step_timeout
+				reqs.push req
+			end
+		}
+		reqs.each {|req| req.call :TimeoutError, nil }
+	end
+
+	private
+	def send_real(method, param, req)
+		method = method.to_s unless method.is_a?(Integer)
+		msgid = @seqid
+		@seqid += 1; if @seqid >= 1<<31 then @seqid = 0 end
+		@sock.send_request msgid, method, param
+		@reqtable[msgid] = req
+	end
+
+	def notify_real(method, param)
+		method = method.to_s unless method.is_a?(Integer)
+		@sock.send_notify method, param
+	end
+end
+
+
+class ServerSession
+	def initialize(obj, accept = obj.public_methods)
+		@obj = obj
+		@accept = accept.map {|m| m.to_s }
+	end
+
+	def add_socket(sock)
+		# do nothing
+	end
+
+	def on_request(method, param, res)
+		begin
+			unless @accept.include?(method)
+				raise NoMethodError, "method `#{method}' is not accepted"
+			end
+			ret = @obj.send(method, *param)
+		rescue
+			res.error($!.to_s)
+			return
+		end
+		res.result(ret)
+	end
+
+	def on_notify(method, param)
+		# FIXME notify support
+		raise RPCError.new("unexpected notify message")
+	end
+
+	def on_response(msgid, error, result)
+		raise RPCError.new("unexpected response message")
+	end
+
+	def on_close(sock)
+		# do nothing
+		@sock = nil
+	end
+end
+
+Loop = ::Rev::Loop
+
+module LoopUtil
+	class Timer < Rev::TimerWatcher
+		def initialize(interval, repeating, &block)
+			@block = block
+			super(interval, repeating)
+		end
+		def on_timer
+			@block.call
+		end
+	end
+
+	def start_timer(interval, repeating, &block)
+		@loop.attach Timer.new(interval, repeating, &block)
+	end
+
+	def run
+		@loop.run
+	end
+
+	def stop
+		@loop.stop
+		# attach dummy timer
+		@loop.attach Rev::TimerWatcher.new(0, false)
+	end
+end
+
+
+class Client
+	def initialize(host, port, loop = Loop.new)
+		@loop = loop
+		@host = host
+		@port = port
+		@rsock = RevSocket.connect(host, port)
+		@s = ClientSession.new(loop)
+		@rsock.session = @s
+		loop.attach(@rsock)
+		@timer = Timer.new(1, true) { @s.step_timeout }
+		loop.attach(@timer)
+	end
+	attr_reader :loop, :host, :port
+
+	def close
+		@timer.detach
+		@rsock.detach
+		@s.close
+	end
+
+	def send(method, *args)
+		@s.send(method, *args)
+	end
+
+	def callback(method, *args, &block)
+		@s.callback(method, *args, &block)
+	end
+
+	def call(method, *args)
+		@s.call(method, *args)
+	end
+
+	def notify(method, *args)
+		@s.notify(method, *args)
+	end
+
+	def timeout
+		@s.timeout
+	end
+
+	def timeout=(time)
+		@s.timeout = time
+	end
+
+	include LoopUtil
+end
+
+
+class Server
+	class Socket < RevSocket
+		def initialize(*args)
+			accept = args.pop
+			obj = args.pop
+			self.session = ServerSession.new(obj, accept)
+			super(*args)
+		end
+	end
+
+	def initialize(loop = Loop.new)
+		@loop = loop
+		@socks = []
+	end
+	attr_reader :loop
+
+	def listen(host, port, obj, accept = obj.public_methods)
+		lsock = ::Rev::TCPServer.new(host, port, Server::Socket, obj, accept)
+		@socks.push lsock
+		@loop.attach(lsock)
+	end
+
+	def close
+		@socks.reject! {|lsock|
+			lsock.detach
+			lsock.close
+			true
+		}
+	end
+
+	include LoopUtil
+end
+
+
+end  # module RPC
+end  # module MessagePack
+

data/test/msgpack_rpc_test.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'test/unit'
+
+$port = 65500
+
+class MessagePackRPCTest < Test::Unit::TestCase
+
+	class MyServer
+		def hello
+			"ok"
+		end
+
+		def sum(a, b)
+			a + b
+		end
+
+		def exception
+			raise "raised"
+		end
+
+		private
+		def hidden
+		end
+	end
+
+
+	def test_listen
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		svr.close
+	end
+
+
+	def test_call
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		Thread.start do
+			svr.run
+		end
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+
+		result = cli.call(:hello)
+		assert_equal(result, "ok")
+
+		result = cli.call(:sum, 1, 2)
+		assert_equal(result, 3)
+
+		cli.close
+	end
+
+
+	def test_send
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		Thread.start do
+			svr.run
+		end
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+
+		req1 = cli.send(:hello)
+		req2 = cli.send(:sum, 1, 2)
+
+		req1.join
+		req2.join
+
+		assert_equal(req1.result, "ok")
+		assert_nil(req1.error)
+		assert_equal(req2.result, 3)
+		assert_nil(req2.error)
+
+		cli.close
+	end
+
+
+	def test_callback
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		Thread.start do
+			svr.run
+		end
+
+		count = 0
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+
+		cli.callback(:hello) do |error, result|
+			assert_equal(result, "ok")
+			assert_nil(error)
+			count += 1
+		end
+
+		cli.callback(:sum, 1, 2) do |error, result|
+			assert_equal(result, 3)
+			assert_nil(error)
+			count += 1
+		end
+
+		while count < 2
+			cli.loop.run_once
+		end
+
+		cli.close
+	end
+
+
+	def test_hidden
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		Thread.start do
+			svr.run
+		end
+
+		count = 0
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+
+		rejected = false
+		begin
+			cli.call(:hidden)
+		rescue MessagePack::RPC::RemoteError
+			rejected = true
+		end
+
+		assert_equal(rejected, true)
+
+		cli.close
+	end
+
+
+	def test_exception
+		port = $port += 1
+
+		svr = MessagePack::RPC::Server.new
+		svr.listen("0.0.0.0", port, MyServer.new)
+		Thread.start do
+			svr.run
+		end
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+
+		raised = false
+		begin
+			cli.call(:exception)
+		rescue MessagePack::RPC::RemoteError
+			assert_equal($!.message, "raised")
+			raised = true
+		end
+
+		assert_equal(raised, true)
+
+		cli.close
+	end
+
+
+	def test_loop
+		port = $port += 1
+
+		loop = MessagePack::RPC::Loop.new
+
+		svr = MessagePack::RPC::Server.new(loop)
+		svr.listen("0.0.0.0", port, MyServer.new)
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port, loop)
+		cli.timeout = 1
+
+		count = 0
+
+		cli.callback(:hello) do |error, result|
+			assert_equal(result, "ok")
+			assert_nil(error)
+			count += 1
+		end
+
+		cli.callback(:sum, 1, 2) do |error, result|
+			assert_equal(result, 3)
+			assert_nil(error)
+			count += 1
+		end
+
+		while count < 2
+			loop.run_once
+		end
+
+		cli.close
+		svr.close
+	end
+
+
+	def test_timeout
+		port = $port += 1
+
+		lsock = TCPServer.new("0.0.0.0", port)
+
+		cli = MessagePack::RPC::Client.new("127.0.0.1", port)
+		cli.timeout = 1
+
+		timeout = false
+		begin
+			cli.call(:hello)
+		rescue MessagePack::RPC::TimeoutError
+			timeout = true
+		end
+
+		assert_equal(timeout, true)
+
+		cli.close
+		lsock.close
+	end
+
+end
+

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/msgpack/rpc'
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: msgpack-rpc
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- FURUHASHI Sadayuki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-18 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: msgpack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rev
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+description: RPC library using MessagePack, a ainary-based efficient data interchange format.
+email: frsyuki _at_ users.sourceforge.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- ChangeLog
+- AUTHORS
+files: 
+- README
+- ChangeLog
+- Rakefile
+- test/msgpack_rpc_test.rb
+- test/test_helper.rb
+- lib/msgpack
+- lib/msgpack/rpc.rb
+- AUTHORS
+has_rdoc: false
+homepage: http://msgpack.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- msgpack-rpc documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: msgpack
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: RPC library using MessagePack, a ainary-based efficient data interchange format.
+test_files: 
+- test/test_helper.rb