rawjsonrpc 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,17 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Alexander Schrode
+
+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/README.rdoc

@@ -0,0 +1,126 @@
+= rawjsonrpc
+
+rawjsonrpc is a libary to create a jsonrpc client for every type of stream. It
+also profides one client for tcpsocket, an server for one client and on server
+based on gserver from the ruby stdlib. 
+This is libary is a my first try in ruby to create a gem. Its more a test how 
+gems work but i hope i can help somebody with this lib. 
+
+== load lib
+
+install libary
+
+  gem install rawjsonrpc
+
+include rawjsonrpc in your programm
+
+  require 'rawjsonrpc'
+
+== Use the TCP client 
+
+Create a client to send rpc calls.
+
+  client = RawJsonRpc::ClientSocket.new('192.168.2.10', 8080) #creates TCP client
+  ret = client.request("func1", nil)                 #calles func1 with no para
+    			     		       	     #returns result in ret
+  ret = client.request("func2", 1, 3.0, :test, "om") #calles func2 with 4 paras
+  ret = client.func3([1, 2, 3, 4])                   #calles func3 with a array
+  client.notification("noti", 1, "t")                #send notifaction no 
+			     			     # #return value
+  client.close()
+
+== Use server TCP simple
+
+Use the libary to serve functions over tcp ip. 
+
+  client = RawJsonRpc::SimpleServerSocket.new(8080)
+  client.add_method("func1", method("do_stuff1")) # adds do_stuff1 as "func1"
+  client.add_method("foo", method(:bar))          # adds bar as foo
+  client.add_block("func2"){|a,b, *c|              # adds a block with 2 args
+    #do stuff 			 		  # and args as func2
+  }
+  client.serve()
+
+== use gserver TCP
+
+Lock in the stdlib for usage. The server delivers automaticly the functions.
+Beware of adding methods or blocks after starting.
+
+
+  server = RawJsonRpc::TCPServer.new(#args)
+
+== implement your own jsonclient
+ 
+Boilerplate Code to create your own client.
+
+  class superclient < RawJsonRpc::RawClientJsonRpc 
+    def initiailize(*args)
+     # init stream
+    end
+  
+    def send_request(jsonstring)
+      #send stream
+    end
+
+    def get_response
+      #return the response
+    end
+
+    def close
+      #close resources if needed
+    end
+  end
+
+== implement your server
+
+The boilerplattecode to create a new server.
+
+  class superserver
+    include RawJsonRpc::RawServerJsonRpc
+
+    def initizial(*args)
+      #init
+    end
+
+    def serve
+      #get data from client
+      response = execute(jsonstring) #transfers the string and calls function
+                                   #return response string or nil if its a
+		  		   # #notification
+      #send response
+    end
+
+    def end
+      #stuff
+    end 
+  end
+
+== known issues
+
+* Block arguments can't be checkt because they are blocks not lamdbas
+
+== Your implementations
+
+feel free to contribute your client and servers to the project.
+
+== TODO 
+* add examples
+* add doc for gserver implementation
+* add a piping server and client
+* fix block argumentchecks
+
+== Contributing to rawjsonrpc
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Alexander Schrode. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rawjsonrpc"
+  gem.homepage = "http://github.com/schroder-/rawjsonrpc"
+  gem.license = "MIT"
+  gem.summary = %Q{A basic libary for json rpc that allow to create for your stream type. It includes a TCPIp Server and Client.}
+  gem.description = %Q{A basic libary for json rpc that allow you to easly create one for your streamtype .It includes tcp json rpc on socket connections. Version for single clients server, one for multiple clients server based on gserver are served and a TCP client.}
+  gem.email = "midix01@googlemail.com"
+  gem.authors = ["Alexander Schrode"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rawjsonrpc #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rawjsonrpc/client.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+# client.rb : Implements the Clientside
+#
+# Copyright January 2012, Alexander Schrode.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'json'
+require 'socket'
+require_relative 'error'
+
+module RawJsonRpc
+  # Implements the base class for all Clients.
+  # The class get all methode calls generate the json data from it
+  #
+  # <b>Every client must implement get_response and send_request</b>.
+  #
+  # =Examples
+  # ==send request
+  #
+  ## client.request("run", [1,2,3])                  # calls: run params: 1 2 3
+  ## ret = client.request("attack", "alpha", 1, 3.0) # calls: attack
+  ##                                                 # params "alpha", 1, 3.0
+  ##                                                 # returns data into ret
+  # ==send request shortcut
+  #
+  ## client.run([1,2,3])
+  ## ret = client.attack("alpha", 1, 3.0)
+  #
+  # ==send notification (no return value)
+  ## client.notification("beat", [:alpha, 123], "fast")
+  #
+  class RawClientJsonRpc
+
+    # redirect calls
+    def method_missing(name, *args)
+      if args.empty?
+        request(name)
+      else
+        request(name, *args)
+      end
+    end
+
+    private
+    def id
+      @id_count ||= 0
+      @id_count += 1
+    end
+
+    public
+    # returns the server response must be implmented
+    def get_response
+      raise NotImplementedError.new("method not overriden")
+    end
+
+    # Send the request to server must be implmented.
+    # takes json string.
+    def send_request para
+      raise NotImplementedError.new("method not overriden")
+    end
+
+    public
+    # Sends a notification to server.
+    # A Notifications don't return any value
+    def notification(function_name, *para)
+      para = {'method' => function_name, 'params' => para, 'id' => nil}
+        .to_json
+      send_request para
+      nil
+    end
+    # Sends a request to server
+    # return a value or raise an RpcException if server sends an error.
+    def request(function_name, *para)
+      id_count = id
+      para = {'method' => function_name, 'params' =>  para, 'id' => id_count}
+        .to_json
+      send_request(para)
+      result = get_response
+      if result.empty? or result == nil
+        raise(RpcError.new("empty respons"))
+      end
+      response = JSON.load(result)
+      if response["error"] != nil
+        raise(RpcError.new(response["error"]))
+      elsif response["id"] != id_count
+        raise(RpcError.new("server send wrong data."))
+      end
+      response["result"]
+    end
+  end
+  # Implements the raw json rpc client over a tcp socket.
+  # Includes the RawClientJsonRpcBase Module
+  class ClientSock < RawClientJsonRpc
+    # Init the socket with host.
+    def initialize(ip, port)
+      @socket = TCPSocket.new(ip, port)
+    end
+    # closes the socket connection
+    def close
+      @socket.close
+    end
+    private
+    def get_response
+      @socket.gets
+    end
+
+    def send_request str
+      @socket.puts str
+    end
+  end
+end

data/lib/rawjsonrpc/error.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# :stopdoc:
+# error.rb : Implements all Error Classes
+#
+# Copyright January 2012, Alexander Schrode.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+# :startdoc:
+
+
+class RpcError < StandardError
+end
+

data/lib/rawjsonrpc/server.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+#
+# server.rb : Implements the base server and some basic servers
+#
+# Copyright January 2012, Alexander Schrode.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'socket'
+require 'logger'
+require 'json'
+require 'gserver'
+require_relative 'error'
+
+module RawJsonRpc
+  # Implements the basic server functions
+  # When implementing a new server type you must only give a jsonstring to the
+  # execute function.
+  # =Example
+  #
+  # Add Functions
+  #
+  ## server.add_method("run", methode(:test)) #adds methode test as "run"
+  ## server.add_block("attack"){ |target, dir, times|
+  ##    #stuff
+  ## }
+  module RawServerJsonRpc
+    # Adds methode to be executed
+    def add_method(name, func)
+      @rawjsonrpc_funcs ||= {}
+      @rawjsonrpc_blocks ||= {}
+      @rawjsonrpc_funcs[name] = func
+    end
+    # Adds blocks that get executed
+    # Arguments can not checkt because they are procs no lambdas if you can
+    # provied a hack plz contribute.
+    def add_block(name, &block)
+      @rawjsonrpc_blocks ||= {}
+      @rawjsonrpc_funcs ||= {}
+      @rawjsonrpc_blocks[name] = block
+    end
+    protected
+    # Handels json string input and calls the methode and returns a return
+    # string or nil if its a notification.
+    def execute(input)
+      begin
+        request_data = JSON.load(input)
+        @rawjsonrpc_noti = if request_data["id"] == nil then true
+                else false
+                end
+        @rawjsonrpc_id = request_data["id"]
+        if @rawjsonrpc_funcs.has_key?(request_data["method"])
+          ret = @rawjsonrpc_funcs[request_data["method"]].call(*request_data["params"])
+        elsif @rawjsonrpc_blocks.has_key?(request_data["method"])
+          ret = @rawjsonrpc_blocks[request_data["method"]].call(*request_data["params"])
+        else
+          @rawjsonrpc_back = request_data
+          raise("No Methode")
+        end
+        if request_data["id"] != nil
+          response_data = {"result" => ret, "error" => nil, "id" => request_data["id"]}
+            .to_json
+        else nil
+        end
+      rescue => ex
+        unless @rawjsonrpc_noti
+          response = {"result" => nil, "error" => ex.message,
+            "id" => @rawjsonrpc_id}.to_json
+        end
+      end
+    end
+  end
+  # Implements RawServerJsonRpcBase for a TCPServer, that can only handle
+  # one client at once.
+  class ServerSocket
+    include RawServerJsonRpc
+    # sets the port for serving. Optimal you can add a logger object to log
+    # server activities.
+    def initialize(port, logger=nil)
+      @port = port
+      @log = logger
+    end
+    private
+    #checks logger
+    def check(logger, para)
+      if @log != nil
+        logger.call(para)
+      end
+    end
+    public
+    # Starts the servering the methods for clients
+    def server
+      check log.level, "start serving data at " + @port.to_s
+      server = TCPServer.new(@port)
+      client = server.accept
+      loop do
+        begin
+          data = client.gets
+          if data == nil or data == "END\n"
+            check @log.info, "client closed connection"
+            client.close
+            client = server.accept
+            next
+          end
+          check @log.info, "recived from client " + data
+          data = execute(data)
+          if data != nil
+            check @log.info, "send to client " + data
+            client.puts(data)
+          end
+        rescue SocketError
+          check @log.info, "client closed connection"
+          client.close
+          client = server.accept
+        #  Exception from get killed
+        rescue Errno::EPIPE
+          check @log.info, "server get killed"
+          exit
+        rescue => ex
+          check @log.fatal, "server get killed from: " + ex.message
+          client.close
+          raise ex
+        end
+      end
+    end
+  end
+  # Implements the RawServerJsonRpcBase as GServer the stdlib SocketServer. For
+  # more information go one to the stdlib.
+  class TCPServer < GServer
+    include RawServerJsonRpc
+  end
+end

data/lib/rawjsonrpc.rb

@@ -0,0 +1,18 @@
+# coding:utf-8
+# License:: MIT
+# Author:: Alexander Schrode( MailTo:: midix01@googlemail.de)
+
+# = RAW JSON RPC
+# The rawjsonrpc libary implements base classes / modules to write jsonrpc or
+# servers. So that you can easly implments for your stream type with minmal
+# efford.
+# Also it provides a TCP client and two TCP Servers.
+# Feel free to provid your implmentations to the project.
+
+module RawJsonRpc
+  # :nodoc:
+  VERSION = "0.0.1"# :nodoc:
+end
+require_relative 'rawjsonrpc/error'
+require_relative 'rawjsonrpc/server'
+require_relative 'rawjsonrpc/client'

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rawjsonrpc'
+
+class Test::Unit::TestCase
+end

data/test/test_rawjsonrpc.rb

@@ -0,0 +1,110 @@
+require 'helper'
+require 'logger'
+
+def no_arg
+  "no arg"
+end
+
+def one_arg(a)
+  a
+end
+
+def two_arg(a, b)
+  b
+end
+
+def three_arg(a, b, c)
+  c
+end
+
+def no
+  "no"
+end
+
+def damaged
+  raise ("error")
+end
+
+class Rawjsonrpc < Test::Unit::TestCase
+  class TestClientOK < RawJsonRpc::RawClientJsonRpc
+    include RawJsonRpc::RawServerJsonRpc
+    def initialize()
+      add_method("no", method(:no_arg))
+      add_method("one", method(:one_arg))
+      add_method("two", method(:two_arg))
+      add_method("three", method(:three_arg))
+      add_method("not", method(:no))
+      add_method("damaged", method(:damaged))
+      add_block("block_add"){ |a, b|
+        a + b
+      }
+      add_block("block_raise"){ |a, b|
+      }
+    end
+    def get_response
+     @data
+    end
+    def send_request(patern)
+     @data = execute(patern)
+    end
+    def close()
+      nil
+    end
+  end
+  #test the simple server request
+  def test_simple_request
+    client = TestClientOK.new()
+    assert_equal("no arg", client.request("no"))
+    assert_equal("one arg", client.request("one", "one arg"))
+    assert_equal(2, client.request("two", 1, 2))
+    assert_equal(3.0, client.request("three", 1.0, 2.0, 3.0))
+    client.close()
+  end
+
+  def test_simple_notification
+    sleep(0.2)
+    client = TestClientOK.new()
+    client.notification("not")
+    client.close()
+  end
+
+  def test_simple_name_request
+    client = TestClientOK.new()
+    assert_equal({"a" => "abc", "b" => [1,2,3]},
+           client.request("one", {:a => "abc", :b => [1,2,3]}))
+    assert_equal("no arg", client.no)
+    assert_equal("a", client.one(:a))
+    assert_equal(3.0, client.two(1.0, 3.0))
+    assert_equal(3, client.three(1, 2, 3))
+    client.close()
+  end
+
+  def test_block
+    client = TestClientOK.new()
+    assert_equal(4, client.block_add(2,2))
+    client.close()
+  end
+
+  def test_simple_exception
+    client = TestClientOK.new()
+    assert_raise(RpcError){
+      #no function
+      client.alpha
+    }
+    assert_raise(RpcError){
+      #wrong arguments
+      client.request("two", "alpha")
+    }
+    assert_raise(RpcError){
+      #call damaged function
+      client.damaged
+    }
+=begin doesnt work because blocks can't check arguments errors!!
+    assert_raise(RpcError){
+      client.block_raise
+    }
+=end
+    client.close()
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: rawjsonrpc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Schrode
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &79053450 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *79053450
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &79052420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *79052420
+description: A basic libary for json rpc that allow you to easly create one for your
+  streamtype .It includes tcp json rpc on socket connections. Version for single clients
+  server, one for multiple clients server based on gserver are served and a TCP client.
+email: midix01@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rawjsonrpc.rb
+- lib/rawjsonrpc/client.rb
+- lib/rawjsonrpc/error.rb
+- lib/rawjsonrpc/server.rb
+- test/helper.rb
+- test/test_rawjsonrpc.rb
+homepage: http://github.com/schroder-/rawjsonrpc
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 211403905
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A basic libary for json rpc that allow to create for your stream type. It
+  includes a TCPIp Server and Client.
+test_files: []