sync_service 0.0.8

data/lib/rpc/lib/rpc/clients/em-http-request.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+# https://github.com/eventmachine/em-http-request
+
+require "eventmachine"
+require "em-http-request"
+
+# Note that we support only HTTP POST. JSON-RPC can be done
+# via HTTP GET as well, but since HTTP POST is the preferred
+# method, I decided to implement only it. More info can is here:
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+module RPC
+  module Clients
+    class EmHttpRequest
+      HEADERS ||= {"Accept" => "application/json-rpc"}
+
+      def initialize(uri)
+        @client = EventMachine::HttpRequest.new(uri)
+        @in_progress = 0
+      end
+
+      def connect
+      end
+
+      def disconnect
+      end
+
+      def run(&block)
+        EM.run do
+          block.call
+
+          # Note: There's no way how to stop the
+          # reactor when there are no remaining events.
+          EM.add_periodic_timer(0.1) do
+            EM.stop if @in_progress == 0
+          end
+        end
+      end
+
+      def send(data, &callback)
+        request = @client.post(head: HEADERS, body: data)
+        @in_progress += 1
+        request.callback do |response|
+          if callback
+            callback.call(response.response)
+          end
+
+          @in_progress -= 1
+        end
+      end
+
+      def async?
+        true
+      end
+    end
+  end
+end

data/lib/rpc/lib/rpc/clients/net-http.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require "uri"
+
+# Note that we support only HTTP POST. JSON-RPC can be done
+# via HTTP GET as well, but since HTTP POST is the preferred
+# method, I decided to implement only it. More info can is here:
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+module Net
+  autoload :HTTP,  "net/http"
+  autoload :HTTPS, "net/https"
+end
+
+module RPC
+  module Clients
+    class NetHttp
+      HEADERS ||= {"Accept" => "application/json-rpc"}
+
+      def initialize(uri)
+        @uri = URI.parse(uri)
+        klass = Net.const_get(@uri.scheme.upcase)
+        @client = klass.new(@uri.host, @uri.port)
+      end
+
+      def connect
+        @client.start
+      end
+
+      def disconnect
+        @client.finish
+      end
+
+      def run(&block)
+        self.connect
+        block.call
+        self.disconnect
+      end
+
+      def send(data)
+        path = @uri.path.empty? ? "/" : @uri.path
+
+        begin
+          @client.post(path, data, HEADERS).body
+        rescue EOFError
+          retry
+        end
+      end
+
+      def async?
+        false
+      end
+    end
+  end
+end

data/lib/rpc/lib/rpc/clients/socket.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require "uri"
+require "socket"
+
+module RPC
+  module Clients
+    class Socket
+      def initialize(uri)
+        @uri = URI.parse(uri)
+
+        # Localhost doesn't work for me for some reason.
+        @uri.host = "127.0.0.1" if @uri.host.eql?("localhost")
+      end
+
+      def connect
+        @client = TCPSocket.new(@uri.host, @uri.port)
+      rescue Errno::ECONNREFUSED
+        raise Errno::ECONNREFUSED.new("You have to start the server first!")
+      end
+
+      def disconnect
+        @client.close
+      end
+
+      def run(&block)
+        self.connect
+        block.call
+        self.disconnect
+      end
+
+      # TODO: support for notifications, probably refactor send to:
+      # def send(encoder, data)
+      #   binary = encoder.encode(data)
+      #   @client.puts(binary)
+      #   @client.readline if data[:id]
+      # end
+      # ... and don't forget to add support for notifications to the example socket server!
+      def send(data)
+        @client.puts(data)
+        @client.readline
+        # TODO: sync vs. async: @socket.read or a callback and a loop
+      end
+
+      def async?
+        false
+      end
+    end
+  end
+end

data/lib/rpc/lib/rpc/encoders/json.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+# http://en.wikipedia.org/wiki/JSON-RPC
+
+begin
+  require "yajl/json_gem"
+rescue LoadError
+  require "json"
+end
+
+module RPC
+  module Encoders
+    module Json
+      # This library works with JSON-RPC 2.0
+      # http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+      JSON_RPC_VERSION ||= "2.0"
+
+      # http://json-rpc.org/wd/JSON-RPC-1-1-WD-20060807.html#ErrorObject
+      module Errors
+        # @note The exceptions are "eaten", because no client should be able to shut the server down.
+        def exception(exception, code = 000, message = "#{exception.class}: #{exception.message}")
+          unless RPC.development?
+            object = {class: exception.class.to_s, message: exception.message, backtrace: exception.backtrace}
+            self.error(message, code, object)
+          else
+            raise exception
+          end
+        end
+
+        def error(message, code, object)
+          error = {name: "JSONRPCError", code: code, message: message, error: object}
+          RPC.log "ERROR #{message} (#{code}) #{error[:error].inspect}"
+          error
+        end
+      end
+
+      class Request
+        attr_reader :data
+        def initialize(method, params, id = self.generate_id)
+          @data = {jsonrpc: JSON_RPC_VERSION, method: method, params: params}
+          @data.merge!(id: id) unless id.nil?
+        end
+
+        def generate_id
+          rand(999_999_999_999)
+        end
+      end
+
+      class Client
+        include Errors
+
+        def encode(method, *args)
+          data = Request.new(method, args).data
+          RPC.log "CLIENT ENCODE #{data.inspect}"
+          data.to_json
+        end
+
+        # Notifications are calls which don't require response.
+        # They look just the same, but they don't have any id.
+        def notification(method, *args)
+          data = Request.new(method, args, nil).data
+          RPC.log "CLIENT ENCODE NOTIFICATION #{data.inspect}"
+          data.to_json
+        end
+
+        # Provide list of requests and notifications to run on the server.
+        #
+        # @example
+        #   ["list", ["/"], ["clear", "logs", nil]]
+        def batch(requests)
+          data = requests.map { |request| Request.new(*request).data }
+          RPC.log "CLIENT ENCODE BATCH #{data.inspect}"
+          data.to_json
+        end
+
+        # TODO: support batch
+        def decode(binary)
+          if binary.nil?
+            raise TypeError.new("#{self.class}#decode takes binary data as an argument, not nil!")
+          end
+
+          object = JSON.parse(binary)
+          RPC.log "CLIENT DECODE #{object.inspect}"
+          object
+        rescue JSON::ParserError => error
+          self.exception(error, -32600, "Invalid Request.")
+        end
+      end
+
+      class Server
+        include Errors
+
+        def decode(binary)
+          object = JSON.parse(binary)
+          RPC.log "SERVER DECODE #{object.inspect}"
+          object
+        rescue JSON::ParserError => error
+          # This is supposed to result in HTTP 500.
+          raise self.exception(error, -32700, "Parse error.")
+        end
+
+        def execute(encoded_result, subject)
+          result = self.decode(encoded_result)
+
+          if result.respond_to?(:merge) # Hash, only one result.
+            self.encode(result_or_error(subject, result))
+          else # Array, multiple results.
+            self.encode(
+              result.map do |result|
+                result_or_error(subject, result)
+              end
+            )
+          end
+        end
+
+        def result_or_error(subject, command)
+          method, args = command["method"], command["params"]
+          result = subject.send(method, *args)
+          self.response(result, nil, command["id"])
+        rescue NoMethodError => error
+          error = self.exception(error, -32601, "Method not found.")
+          self.response(nil, error, command["id"])
+        rescue ArgumentError => error
+          error = self.exception(error, -32602, "Invalid params.")
+          self.response(nil, error, command["id"])
+        rescue Exception => exception
+          error = self.exception(exception)
+          self.response(nil, error, command["id"])
+        end
+
+        def response(result, error, id)
+          {jsonrpc: JSON_RPC_VERSION, result: result, error: error, id: id}
+        end
+
+        def encode(response)
+          RPC.log "SERVER ENCODE: #{response.inspect}"
+          response.to_json
+        end
+      end
+    end
+  end
+end

data/lib/rpc/rpc.gemspec

@@ -0,0 +1,34 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+require "base64"
+
+Gem::Specification.new do |s|
+  s.name = "rpc"
+  s.version = "0.3.1"
+  s.authors = ["Jakub Stastny aka botanicus"]
+  s.homepage = "http://github.com/ruby-amqp/rpc"
+  s.summary = "Generic RPC library for Ruby."
+  s.description = "#{s.summary} Currently it supports JSON-RPC over HTTP, support for AMQP and Redis will follow soon."
+  s.cert_chain = []
+  s.email = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  s.has_rdoc = true
+
+  # files
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  # Ruby version
+  s.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+
+  begin
+    require "changelog"
+  rescue LoadError
+    warn "You have to have changelog gem installed for post install message"
+  else
+    s.post_install_message = CHANGELOG.new.version_changes
+  end
+
+  # RubyForge
+  s.rubyforge_project = "rpc"
+end

data/lib/sync_service.rb

@@ -0,0 +1,20 @@
+# Standard
+require 'syslog'
+
+# Gems
+require "rack/request"
+require 'thin'
+
+# Bundled RPC
+$:.push(Pathname.new(File.dirname(__FILE__)).join('rpc', 'lib').to_path)
+require 'rpc'
+
+# Local
+require_relative 'mobme/infrastructure/rpc/version'
+require_relative 'mobme/infrastructure/rpc/error'
+require_relative 'mobme/infrastructure/rpc/base'
+require_relative 'mobme/infrastructure/rpc/adaptor'
+require_relative 'mobme/infrastructure/rpc/runner'
+
+# Alias the client too
+SyncService::Client = RPC::Client

data/spec/adaptor_spec.rb

@@ -0,0 +1,104 @@
+# Gems
+require 'rspec'
+
+# Local
+require_relative 'spec_helper'
+require_relative '../lib/async_service'
+
+module MobME::Infrastructure::RPC
+  describe Adaptor do
+    let(:dummy_service_object) { double "DummyService" }
+    let(:dummy_server) { double(RPC::Server).as_null_object }
+
+    before :each do
+      RPC::Server.stub(:new).and_return(dummy_server)
+    end
+
+    subject { Adaptor.new dummy_service_object }
+
+    it "accepts service object" do
+      Adaptor.should respond_to(:new).with(1).argument
+      Adaptor.new dummy_service_object
+    end
+
+    it { should respond_to(:server).with(0).arguments }
+    it { should respond_to(:call).with(1).argument }
+    it { should respond_to(:response).with(2).arguments }
+
+    describe "#server" do
+      it "creates an instance of RPC::Server" do
+        RPC::Server.should_receive(:new).with(dummy_service_object)
+        subject.server
+      end
+
+      it "returns an instance of RPC::Server" do
+        subject.server.should be dummy_server
+      end
+
+      context "when called multiple times" do
+        it "returns the same (original) instance of RPC::Server" do
+          subject.server.should be dummy_server
+          second_dummy_server = double(RPC::Server)
+          RPC::Server.stub(:new).and_return(second_dummy_server)
+          subject.server.should be dummy_server
+        end
+      end
+    end
+
+    describe "#call" do
+      let(:dummy_environment) { double("Environment") }
+      let(:dummy_command) { double("Request Command") }
+      let(:dummy_body) { double("Request Body", :read => dummy_command) }
+      let(:dummy_request) { double(Rack::Request, :body => dummy_body) }
+
+      before :each do
+        Rack::Request.stub(:new).and_return(dummy_request)
+        subject.stub(:response)
+      end
+
+      it "creates a new rack request object" do
+        Rack::Request.should_receive(:new).with(dummy_environment)
+        subject.call(dummy_environment)
+      end
+
+      it "extracts command from request" do
+        dummy_request.should_receive(:body)
+        dummy_body.should_receive(:read)
+        subject.call(dummy_environment)
+      end
+
+      it "executes the extracted command" do
+        dummy_server.stub(:execute).and_return(double("Binary Response").as_null_object)
+        dummy_server.should_receive(:execute).with(dummy_command)
+        subject.call(dummy_environment)
+      end
+
+      context "when response from executed command contains string NoMethodError" do
+        it "calls response method with status 404" do
+          dummy_server.stub(:execute).and_return('NoMethodError')
+          subject.should_receive(:response).with(404, 'NoMethodError')
+          subject.call(dummy_environment)
+        end
+      end
+
+      context "when response from executed command does not contain NoMethodError" do
+        it "calls response method with status 200" do
+          dummy_server.stub(:execute).and_return('Method Exists!')
+          subject.should_receive(:response).with(200, 'Method Exists!')
+          subject.call(dummy_environment)
+        end
+      end
+    end
+
+    describe "#response" do
+      it "returns response array acceptable to Rack" do
+        dummy_body = "Dummy Body Content"
+        headers = {
+          "Content-Type" => "application/json-rpc",
+          "Content-Length" => dummy_body.bytesize.to_s
+        }
+        subject.response(200, dummy_body).should == [200, headers, [dummy_body]]
+      end
+    end
+  end
+end