sync_service 0.0.8

data/lib/mobme/infrastructure/rpc/base.rb

@@ -0,0 +1,15 @@
+module MobME::Infrastructure::RPC
+  class Base
+    def self.service_name
+      @service_name
+    end
+
+    def logger
+      unless Syslog.opened?
+        Syslog.open(self.class.service_name, Syslog::LOG_PID | Syslog::LOG_CONS)
+      end
+
+      Syslog
+    end
+  end
+end

data/lib/mobme/infrastructure/rpc/error.rb

@@ -0,0 +1,3 @@
+module MobME::Infrastructure::RPC
+  class Error < StandardError; end
+end

data/lib/mobme/infrastructure/rpc/runner.rb

@@ -0,0 +1,21 @@
+module MobME::Infrastructure::RPC
+  class Runner
+    def self.start(application, host, port, route)
+      begin
+        require "thin"
+      rescue LoadError
+        puts "Thin must be installed to use the server, please add thin to your Gemfile"
+        exit
+      end
+
+      Thin::Server.start(host, port) do
+        # Since no logger is specified, this will log apache-style strings to STDERR for each request.
+        use Rack::CommonLogger
+
+        map route do
+          run Adaptor.new(application)
+        end
+      end
+    end
+  end
+end

data/lib/mobme/infrastructure/rpc/version.rb

@@ -0,0 +1,14 @@
+module MobME
+  module Infrastructure
+    module RPC
+      VERSION = '0.0.8'
+      class Adaptor; end
+      class Runner; end
+      class Base; end
+      class Error < StandardError; end
+    end
+  end
+end
+
+# Alias it
+SyncService = MobME::Infrastructure::RPC

data/lib/rpc/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+/*.gem

data/lib/rpc/CHANGELOG

@@ -0,0 +1,10 @@
+= Version 0.3
+  * [FEATURE] Added TCP/IP communication layer.
+
+= Version 0.2
+  * [FEATURE] Full JSON-RPC 2.0 support (added batch, errors and notifications).
+
+= Version 0.1
+  * [FEATURE] Net::HTTP(S) client.
+  * [FEATURE] EM HTTP Request client.
+  * [FEATURE] JSON-RPC encoder.

data/lib/rpc/Gemfile

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+source "http://gemcutter.org"
+
+group(:examples) do
+  gem "rack"
+end
+
+group(:em) do
+  gem "em-http-request"
+end
+
+# group(:amqp) do
+#   gem "amq-client"
+# end
+
+group(:test) do
+  gem "rspec", ">=2.0.0"
+end

data/lib/rpc/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jakub Stastny aka botanicus
+
+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/lib/rpc/README.textile

@@ -0,0 +1,7 @@
+h1. About
+
+Generic RPC library for Ruby. Currently it supports JSON-RPC over HTTP, support for AMQP and Redis will follow soon.
+
+h1. Usage
+
+See examples.

data/lib/rpc/examples/em-http-request-json/client.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+
+RPC.logging = true
+
+client = RPC::Clients::EmHttpRequest.new("http://127.0.0.1:8081")
+
+RPC::Client.new(client) do |client|
+  # Get result of an existing method.
+  client.server_timestamp do |result, error|
+    puts "Server timestamp is #{result}"
+  end
+
+  # Get result of a non-existing method via method_missing.
+  client.send(:+, 1) do |result, error|
+    puts "Method missing works: #{result}"
+  end
+
+  # Synchronous error handling.
+  client.buggy_method do |result, error|
+    STDERR.puts "EXCEPTION CAUGHT:"
+    STDERR.puts "#{error.class} #{error.message}"
+  end
+
+  # Notification isn't supported, because HTTP works in
+  # request/response mode, so it does behave in the same
+  # manner as RPC via method_missing. Sense of this is
+  # only to check, that it won't blow up.
+  puts "Sending a notification ..."
+  client.notification(:log, "Some shit.")
+
+  # Batch.
+  result = client.batch([[:log, ["Message"], nil], [:a_method, []]])
+  puts "Batch result: #{result}"
+end

data/lib/rpc/examples/helpers.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+class RemoteObject
+  def server_timestamp
+    Time.now.to_i
+  end
+
+  def buggy_method
+    raise "This exception is expected."
+  end
+
+  def method_missing(name, *args)
+    "[SERVER] received method #{name} with #{args.inspect}"
+  end
+end

data/lib/rpc/examples/net-http-json/client.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+
+RPC.logging = true
+
+client = RPC::Client.setup("http://127.0.0.1:8081")
+
+# Get result of an existing method.
+puts "Server timestamp is #{client.server_timestamp}"
+
+# Get result of a non-existing method via method_missing.
+puts "Method missing works: #{client + 1}"
+
+# Synchronous error handling.
+begin
+  client.buggy_method
+rescue Exception => exception
+  STDERR.puts "EXCEPTION CAUGHT: #{exception.inspect}"
+end
+
+# Notification isn't supported, because HTTP works in
+# request/response mode, so it does behave in the same
+# manner as RPC via method_missing. Sense of this is
+# only to check, that it won't blow up.
+puts "Sending a notification ..."
+client.notification(:log, "Some shit.")
+
+# Batch.
+result = client.batch([[:log, ["Message"], nil], [:a_method, []]])
+puts "Batch result: #{result}"

data/lib/rpc/examples/net-http-json/console.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+require "irb"
+
+@client = RPC::Client.setup("http://127.0.0.1:8081")
+
+puts "~ RPC Client initialised, use @client to access it."
+
+IRB.start(__FILE__)

data/lib/rpc/examples/server.ru

@@ -0,0 +1,42 @@
+#!/usr/bin/env rackup --port 8081
+# encoding: utf-8
+
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require "rpc"
+require "rack/request"
+
+require_relative "helpers"
+
+RPC.logging = true
+# RPC.development = true
+
+class RpcRunner
+  def server
+    @server ||= RPC::Server.new(RemoteObject.new)
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    command = request.body.read
+    binary  = self.server.execute(command)
+    if binary.match(/NoMethodError/)
+      response(404, binary)
+    else
+      response(200, binary)
+    end
+  end
+
+  def response(status, body)
+    headers = {
+      "Content-Type" => "application/json-rpc",
+      "Content-Length" => body.bytesize.to_s}
+    [status, headers, [body]]
+  end
+end
+
+map("/") do
+  run RpcRunner.new
+end

data/lib/rpc/examples/socket-json/client.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+
+RPC.logging = true
+
+# TODO: the second argument could be +/- guessed (amqp -> amqp adapter, ip -> socket)
+# TODO: IP isn't any existing URI scheme, on the other hand there are so many not existing URI schemes today that I don't think it matters (rsync://, git://, javascript:// and I could go on)
+client = RPC::Client.setup("ip://localhost:2200", RPC::Clients::Socket)
+
+# Get result of an existing method.
+puts "Server timestamp is #{client.server_timestamp}"
+
+# Get result of a non-existing method via method_missing.
+puts "Method missing works: #{client + 1}"
+
+# Synchronous error handling.
+begin
+  client.buggy_method
+rescue Exception => exception
+  STDERR.puts "EXCEPTION CAUGHT: #{exception.inspect}"
+end
+
+# Notification isn't supported, because HTTP works in
+# request/response mode, so it does behave in the same
+# manner as RPC via method_missing. Sense of this is
+# only to check, that it won't blow up.
+puts "Sending a notification ..."
+client.notification(:log, "Some shit.")
+
+# Batch.
+result = client.batch([[:log, ["Message"], nil], [:a_method, []]])
+puts "Batch result: #{result}"

data/lib/rpc/examples/socket-json/server.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+require "socket"
+
+require_relative "../helpers"
+
+RPC.logging = true
+# RPC.development = true
+
+# Helpers.
+def wait_for_client(server_socket)
+  # Block for incoming connection from client by accept method.
+  # The return value of accept contains the new client socket
+  # object and the remote socket address
+  client, client_sockaddr = server_socket.accept
+
+  trap(:TERM) { server_socket.close }
+
+  [client, client_sockaddr]
+end
+
+server_socket = TCPServer.new("127.0.0.1", 2200)
+
+client, client_sockaddr = wait_for_client(server_socket)
+
+server = RPC::Server.new(RemoteObject.new)
+
+begin
+  while data = client.readline.chomp
+    result = server.execute(data)
+    client.puts(result)
+  end
+rescue Errno::ECONNRESET, EOFError
+  # This occurs when client closes the connection. We can safely ignore it.
+  client, client_sockaddr = wait_for_client(server_socket)
+  retry
+end

data/lib/rpc/lib/rpc.rb

@@ -0,0 +1,166 @@
+# encoding: utf-8
+
+module RPC
+  module Clients
+    autoload :NetHttp, "rpc/clients/net-http"
+    autoload :EmHttpRequest, "rpc/clients/em-http-request"
+    autoload :Socket, "rpc/clients/socket"
+  end
+
+  module Encoders
+    autoload :Json, "rpc/encoders/json"
+  end
+
+  def self.logging
+    @logging ||= $DEBUG
+  end
+
+  def self.logging=(boolean)
+    @logging = boolean
+  end
+
+  def self.log(message)
+    STDERR.puts(message) if self.logging
+  end
+
+  def self.development=(boolean)
+    @development = boolean
+  end
+
+  def self.development?
+    !! @development
+  end
+
+  def self.full_const_get(const_name)
+    parts = const_name.sub(/^::/, "").split("::")
+    parts.reduce(Object) do |constant, part|
+      constant.const_get(part)
+    end
+  end
+
+  class Server
+    def initialize(subject, encoder = RPC::Encoders::Json::Server.new)
+      @subject, @encoder = subject, encoder
+    end
+
+    def execute(encoded_command)
+      @encoder.execute(encoded_command, @subject)
+    end
+  end
+
+  module ExceptionsMixin
+    attr_accessor :server_backtrace
+
+    # NOTE: We can't use super to get the client backtrace,
+    # because backtrace is generated only if there is none
+    # yet and because we are redefining the backtrace method,
+    # there always will be some backtrace.
+    def backtrace
+      @backtrace ||= begin
+        caller(3) + ["... server ..."] + self.server_backtrace
+      end
+    end
+  end
+
+  class Client < BasicObject
+    def self.setup(uri, client_class = Clients::NetHttp, encoder = Encoders::Json::Client.new)
+      client = client_class.new(uri)
+      self.new(client, encoder)
+    end
+
+    def initialize(client, encoder = Encoders::Json::Client.new, &block)
+      @client, @encoder = client, encoder
+
+      if block
+        @client.run do
+          block.call(self)
+        end
+      else
+        @client.connect
+      end
+    end
+
+    def notification(*args)
+      data = @encoder.notification(*args)
+      @client.send(data)
+    end
+
+    def batch(*args)
+      data = @encoder.batch(*args)
+      @client.send(data)
+    end
+
+    # 1) Sync: it'll return the value.
+    # 2) Async: you have to add #subscribe
+
+    # TODO: this should be refactored and moved to the encoder,
+    # because result["error"] and similar are JSON-RPC-specific.
+    def method_missing(method, *args, &callback)
+      binary = @encoder.encode(method, *args)
+
+      if @client.async? && ! callback # Assume notification.
+        @client.send(binary)
+      elsif @client.async? && callback
+        @client.send(binary) do |encoded_result|
+          result = @encoder.decode(encoded_result)
+
+          if result.respond_to?(:merge) # Hash, only one result.
+            callback.call(result["result"], get_exception(result["error"]))
+          else # Array, multiple results.
+            result.map do |result|
+              callback.call(result["result"], get_exception(result["error"]))
+            end
+          end
+        end
+      else
+        ::Kernel.raise("You can't specify callback for a synchronous client.") if callback
+
+        encoded_result = @client.send(binary)
+
+        if encoded_result.nil?
+          ::Kernel.raise("Bug in #{@client.class}#send(data), it can never return nil in the sync mode!")
+        end
+
+        result = @encoder.decode(encoded_result)
+
+        if result.respond_to?(:merge) # Hash, only one result.
+          result_or_raise(result)
+        else # Array, multiple results.
+          result.map do |result|
+            result_or_raise(result)
+          end
+        end
+      end
+    end
+
+    def result_or_raise(result)
+      if error = result["error"]
+        exception = self.get_exception(error)
+        ::Kernel.raise(exception)
+      else
+        result["result"]
+      end
+    end
+
+    def get_exception(error)
+      return unless error
+      exception = error["error"]
+      resolved_class = ::RPC.full_const_get(exception["class"])
+      klass = resolved_class || ::RuntimeError
+      message = resolved_class ? exception["message"] : error["message"]
+      case klass.instance_method(:initialize).arity
+        when 2
+          instance = klass.new(message, nil)
+        else
+          instance = klass.new(message)
+      end
+      instance.extend(::RPC::ExceptionsMixin)
+      instance.server_backtrace = exception["backtrace"]
+      instance
+    end
+
+    def close_connection
+      @client.disconnect
+    end
+  end
+end