xmlrpcs 0.1

data/README

@@ -0,0 +1,24 @@
+This gems allow to easily change the transport layer in XMLRPC::Client class.
+It adds a new class called XMLRPC::ClientS, subclass of the Client class. This
+class must be subclassed to put your own transport code in it.
+
+There are 3 private method that can be changed.
+
+*new_socket* (info,async)
+This method is called to create a new socket. Info is the parameter you passed 
+to the constructor and async is a boolean value that tells you if the socket
+should be asyncrhonous.
+The object returned must answer to read and write methods.
+
+*read_response* (socket)
+Must read the response from the socket and return the data. You may leave this
+the default, but it will wait until the socket is closed.
+
+*write_request* (socket,request)
+Writes the request in the socket, this may be left as it is.
+
+
+write_request and read_response have to be changed to use a specific protocol if you don't want the socket to be closed.
+In the test i use a very simple one for instance which needs no explanation.
+
+Author: Dario Meloni <mellon85@gmail.com>

data/lib/xmlrpc/xmlrpcs.rb

@@ -0,0 +1,59 @@
+require 'xmlrpc/client'
+
+
+# This gems allow to easily change the transport layer in XMLRPC::Client class.
+# It adds a new class called XMLRPC::ClientS, subclass of the Client class.
+
+module XMLRPC
+
+
+    # This class must be subclassed to put your own transport code in it.
+    # There are 3 private method that are to be changed.
+    #
+    # new_socket +MUST+ be redefined or will raise a NotImplementedError, while
+    # write_request and read_response have to be changed to use a specific
+    # protocol, the default is that there is no control on the write operation
+    # and the receiving the response is ended by the closoure of the socket.  In
+    # the test i use a very simple protocol for instance which needs no
+    # explanation.
+
+    class ClientS < XMLRPC::Client
+
+        # The info parameter will be passed to the new_socket function as it is
+        def initialize(info=nil)
+            @info = info
+        end
+        
+        private
+       
+        # This is called to create a new socket. Info is the parameter you
+        # passed to the constructor and async is a boolean value that tells you
+        # if the socket should be asyncrhonous.  The object returned must answer
+        # to read and write methods.
+        def new_socket(info,async) # :doc:
+            raise NotImplementedError, "new_socket must be redefined"
+        end
+
+        # Writes the request in the socket, this may be left as it is.
+        def write_request(socket,request) # :doc:
+          if socket.write(request) != request.length then
+              raise IOError, "Not all the data has been sent"
+          end
+        end
+
+        # Must read the response from the socket and return the data. You may
+        # leave this the default, the default behavious is to wait until the
+        # socket is closed.
+        def read_response(socket) # :doc:
+            socket.read()
+        end
+
+        # do_rpc working with custom sockets
+        def do_rpc( request, async )
+          sock = new_socket(@info,async)
+          write_request(sock,request)
+          return read_response(sock)
+        end
+    end
+end
+

data/test/xmlrpc/tc_tcp.rb

@@ -0,0 +1,69 @@
+#! /usr/bin/ruby
+# Author: Dario Meloni <mellon85@gmail.com>
+
+require 'test/unit'
+require 'xmlrpcs'
+require 'xmlrpc/server'
+require 'socket'
+
+$test_port="20000"
+
+class TCPXMLClient < XMLRPC::ClientS
+    def new_socket(info,async)
+        TCPSocket.new(info["host"],info["port"])
+    end
+
+    def write_request(socket,request)
+        socket.write("#{request.length}\n")
+        socket.write(request)
+    end
+
+    def read_response(socket)
+        l = socket.readline
+        return socket.read(l.to_i)
+    end
+end
+
+class TCPXMLServer < XMLRPC::BasicServer
+
+    def serve()
+        @server = TCPServer.new('localhost',20000)
+        catch (:exit_serve) {
+        while(true)
+            @server.listen(5)
+            client, client_addr = @server.accept
+            l = client.readline
+            data = client.read(l.to_i)
+            pdata = process(data)
+            client.write("#{pdata.length}\n")
+            client.write(pdata)
+            client.close
+        end
+        }
+    end
+
+    attr_accessor :path
+end
+
+class TC_xmlrpcs_tcp < Test::Unit::TestCase
+    def setup
+        @s = TCPXMLServer.new()
+        @s.add_introspection
+        @s.add_handler("test.add") do |a,b|
+            a+b
+        end
+        @t = Thread.new do
+            @s.serve
+        end
+    end
+
+    def teardown
+        Thread.kill(@t)
+    end
+
+    def test_create
+        c = TCPXMLClient.new({"host" => "localhost", "port" => "#{$test_port}"})
+        assert(c.call("test.add",2,3) == 5, "Failed calling test.add")
+        assert(c.call("system.listMethods"),"Failed system.listMethods")
+    end
+end

data/test/xmlrpc/tc_unix.rb

@@ -0,0 +1,71 @@
+#! /usr/bin/ruby
+# Author: Dario Meloni <mellon85@gmail.com>
+
+require 'test/unit'
+require 'xmlrpcs'
+require 'xmlrpc/server'
+require 'socket'
+
+$socket_path="test.sock"
+
+class UnixXMLClient < XMLRPC::ClientS
+    def new_socket(info,async)
+        UNIXSocket.new(info)
+    end
+
+    def write_request(socket,request)
+        socket.write("#{request.length}\n")
+        socket.write(request)
+    end
+
+    def read_response(socket)
+        l = socket.readline
+        return socket.read(l.to_i)
+    end
+end
+
+class UnixXMLServer < XMLRPC::BasicServer
+
+    def serve()
+        @server = UNIXServer.new(@path)
+        catch (:exit_serve) {
+        while(true)
+            @server.listen(5)
+            client, client_addr = @server.accept
+            l = client.readline
+            data = client.read(l.to_i)
+            pdata = process(data)
+            client.write("#{pdata.length}\n")
+            client.write(pdata)
+            client.close
+        end
+        }
+    end
+
+    attr_accessor :path
+end
+
+class TC_xmlrpcs_unix < Test::Unit::TestCase
+    def setup
+        @s = UnixXMLServer.new()
+        @s.path=$socket_path
+        @s.add_introspection
+        @s.add_handler("test.add") do |a,b|
+            a+b
+        end
+        @t = Thread.new do
+            @s.serve
+        end
+    end
+
+    def teardown
+        Thread.kill(@t)
+        File.unlink($socket_path)
+    end
+
+    def test_create
+        c = UnixXMLClient.new($socket_path)
+        assert(c.call("test.add",2,3) == 5, "Failed calling test.add")
+        assert(c.call("system.listMethods"),"Failed system.listMethods")
+    end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: xmlrpcs
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Dario Meloni
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-26 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mellon85@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/xmlrpc/xmlrpcs.rb
+- test/xmlrpc/tc_tcp.rb
+- test/xmlrpc/tc_unix.rb
+- README
+has_rdoc: true
+homepage: http://rubyforge.org/projects/xmlrpcs/
+post_install_message: 
+rdoc_options: []
+
+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: xmlrpcs
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Changes sockets for the XMLRPC Library
+test_files: 
+- test/xmlrpc/tc_tcp.rb
+- test/xmlrpc/tc_unix.rb