hprose 1.4.1

data/README.md

@@ -0,0 +1,29 @@
+# Hprose for Ruby
+
+*Hprose* is a High Performance Remote Object Service Engine.
+
+It is a modern, lightweight, cross-language, cross-platform, object-oriented, high performance, remote dynamic communication middleware. It is not only easy to use, but powerful. You just need a little time to learn, then you can use it to easily construct cross language cross platform distributed application system.
+
+*Hprose* supports many programming languages, for example:
+
+* AAuto Quicker
+* ActionScript
+* ASP
+* C++
+* Dart
+* Delphi/Free Pascal
+* dotNET(C#, Visual Basic...)
+* Golang
+* Java
+* JavaScript
+* Node.js
+* Objective-C
+* Perl
+* PHP
+* Python
+* Ruby
+* ...
+
+Through *Hprose*, You can conveniently and efficiently intercommunicate between those programming languages.
+
+This project is the implementation of Hprose for Ruby.

data/examples/client.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'hprose'
+
+client = HproseHttpClient.new('http://localhost:3000/')
+def error(name, e)
+  puts name
+  puts e
+end
+client.onerror = :error
+
+math = client.use_service(nil, :math)
+
+client.hello('World') { |result|
+  puts result
+}
+
+math.add(1, 2) { |result|
+  puts result
+}.join
+
+math.sub(1, 2) { |result|
+  puts result
+}.join
+
+puts client.sum(1,3,4,5,6,7)
+user = client.getUser()
+puts user.name
+puts user.age
+
+puts client.hi('hprose')
+puts client.push([user, user, user])

data/examples/server.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rack'
+require 'hprose'
+
+def hello(name)
+  return 'hello ' << name << '!'
+end
+
+class User
+  def initialize()
+    @name = "Tom"
+    @age = 28
+  end
+end
+
+def getUser()
+  return User.new()
+end
+
+
+class MyService
+  def add(a, b)
+    return a + b
+  end
+  def sub(a, b)
+    return a - b
+  end
+end
+
+def mf(name, args)
+  return name << " => " << HproseFormatter.serialize(args)
+end
+
+HproseClassManager.register(User, "User")
+
+app = HproseHttpService.new()
+
+app.add(:hello)
+app.add(:sum) { |*num|
+  result = 0
+  num.each { |item| result += item }
+  result
+}
+app.add(:getUser)
+app.add_missing_function(:mf)
+app.add(MyService.new, :math)
+app.debug = true
+Rack::Handler::WEBrick.run(app, {:Port => 3000})

data/lib/hprose/client.rb

@@ -0,0 +1,156 @@
+############################################################
+#                                                          #
+#                          hprose                          #
+#                                                          #
+# Official WebSite: http://www.hprose.com/                 #
+#                   http://www.hprose.net/                 #
+#                   http://www.hprose.org/                 #
+#                                                          #
+############################################################
+
+############################################################
+#                                                          #
+# hprose/client.rb                                         #
+#                                                          #
+# hprose client for ruby                                   #
+#                                                          #
+# LastModified: Mar 8, 2014                                #
+# Author: Ma Bingyao <andot@hprose.com>                    #
+#                                                          #
+############################################################
+
+require "hprose/common"
+require "hprose/io"
+
+module Hprose
+  class Client
+    include Tags
+    include ResultMode
+    public
+    def initialize(uri = nil)
+      @onerror = nil
+      @filter = Filter.new
+      @simple = false
+      self.uri = uri
+    end
+    def uri=(uri)
+      @uri = URI.parse(uri) unless uri.nil?
+    end
+    attr_reader :uri
+    attr_accessor :filter, :simple
+    def onerror(&block)
+      @onerror = block if block_given?
+      @onerror
+    end
+    def onerror=(error_handler)
+      error_handler = error_handler.to_sym if error_handler.is_a?(String)
+      if error_handler.is_a?(Symbol) then
+        error_handler = Object.method(error_handler)
+      end
+      @onerror = error_handler
+    end
+    def use_service(uri = nil, namespace = nil)
+      self.uri = uri
+      Proxy.new(self, namespace)
+    end
+    def [](namespace)
+      Proxy.new(self, namespace)
+    end
+    def invoke(methodname, args = [], byref = false, resultMode = Normal, simple = nil, &block)
+      simple = @simple if simple.nil?
+      if block_given? then
+        Thread.start do
+          begin
+            result = do_invoke(methodname, args, byref, resultMode, simple)
+            case block.arity
+            when 0 then yield
+            when 1 then yield result
+            when 2 then yield result, args
+            end
+          rescue ::Exception => e
+            @onerror.call(methodname, e) if (@onerror.is_a?(Proc) or
+                                             @onerror.is_a?(Method) or
+                                             @onerror.respond_to?(:call))
+          end
+        end
+      else
+        return do_invoke(methodname, args, byref, resultMode, simple)
+      end
+    end
+    protected
+    def send_and_receive(data)
+      raise NotImplementedError.new("#{self.class.name}#send_and_receive is an abstract method")
+    end
+    private
+    def do_output(methodname, args, byref, simple)
+      stream = StringIO.new
+      writer = Writer.new(stream, simple)
+      stream.putc(TagCall)
+      writer.write_string(methodname.to_s)
+      if (args.size > 0 or byref) then
+        writer.reset
+        writer.write_list(args)
+        writer.write_boolean(true) if byref
+      end
+      stream.putc(TagEnd)
+      data = @filter.output_filter(stream.string)
+      stream.close
+      return data
+    end
+    def do_input(data, args, resultMode)
+      data = @filter.input_filter(data)
+      raise Exception.exception("Wrong Response: \r\n#{data}") if data[data.size - 1].ord != TagEnd
+      return data if resultMode == RawWithEndTag
+      return data.chop! if resultMode == Raw
+      stream = StringIO.new(data, 'rb')
+      reader = Reader.new(stream)
+      result = nil
+      while (tag = stream.getbyte) != TagEnd do
+        case tag
+        when TagResult then
+          if resultMode == Normal then
+            reader.reset
+            result = reader.unserialize
+          else
+            s = reader.read_raw
+            result = s.string
+            s.close
+          end
+        when TagArgument then
+          reader.reset
+          a = reader.read_list
+          args.each_index { |i| args[i] = a[i] }
+        when TagError then
+          reader.reset
+          result = Exception.exception(reader.read_string())
+        else
+          raise Exception.exception("Wrong Response: \r\n#{data}")
+        end
+      end
+      return result
+    end
+    def do_invoke(methodname, args, byref, resultMode, simple)
+      data = do_output(methodname, args, byref, simple)
+      result = do_input(send_and_receive(data), args, resultMode)
+      raise result if result.is_a?(Exception)
+      return result
+    end
+    def method_missing(methodname, *args, &block)
+      self.invoke(methodname, args, &block)
+    end
+
+    class Proxy
+      def initialize(client, namespace = nil)
+        @client = client
+        @namespace = namespace
+      end
+      def [](namespace)
+        Proxy.new(@client, @namespace.to_s + '_' + namespace.to_s)
+      end
+      def method_missing(methodname, *args, &block)
+        methodname = @namespace.to_s + '_' + methodname.to_s unless @namespace.nil?
+        @client.invoke(methodname, args, &block)
+      end
+    end # class Proxy
+  end # class Client
+end # module Hprose

data/lib/hprose/common.rb

@@ -0,0 +1,41 @@
+############################################################
+#                                                          #
+#                          hprose                          #
+#                                                          #
+# Official WebSite: http://www.hprose.com/                 #
+#                   http://www.hprose.net/                 #
+#                   http://www.hprose.org/                 #
+#                                                          #
+############################################################
+
+############################################################
+#                                                          #
+# hprose/common.rb                                         #
+#                                                          #
+# hprose common library for ruby                           #
+#                                                          #
+# LastModified: Dec 2, 2012                                #
+# Author: Ma Bingyao <andot@hprose.com>                    #
+#                                                          #
+############################################################
+
+module Hprose
+  class Exception < Exception; end
+
+  module ResultMode
+    Normal = 0
+    Serialized = 1
+    Raw = 2
+    RawWithEndTag = 3
+  end
+
+  class Filter
+    def input_filter(data)
+      return data
+    end
+    def output_filter(data)
+      return data
+    end
+  end
+
+end # module Hprose

data/lib/hprose/httpclient.rb

@@ -0,0 +1,141 @@
+############################################################
+#                                                          #
+#                          hprose                          #
+#                                                          #
+# Official WebSite: http://www.hprose.com/                 #
+#                   http://www.hprose.net/                 #
+#                   http://www.hprose.org/                 #
+#                                                          #
+############################################################
+
+############################################################
+#                                                          #
+# hprose/httpclient.rb                                     #
+#                                                          #
+# hprose http client for ruby                              #
+#                                                          #
+# LastModified: Mar 8, 2014                                #
+# Author: Ma Bingyao <andot@hprose.com>                    #
+#                                                          #
+############################################################
+
+require "hprose/client"
+require "net/http"
+require "net/https"
+require "uri"
+
+module Hprose
+  class HttpClient < Client
+    include Tags
+    @@cookie_manager = {}
+    @@cookie_manager_mutex = Mutex.new
+    public
+    def initialize(uri = nil)
+      super
+      Net::HTTP.version_1_2
+      @http = Net::HTTP
+      @header = {}
+      @timeout = 30
+      @keepalive = false
+      @keepalive_timeout = 300
+    end
+    attr_reader :header
+    attr_accessor :timeout, :keepalive, :keepalive_timeout
+    def proxy=(proxy)
+      @http = case proxy
+      when Net::HTTP then
+        proxy
+      when String then
+        uri = URI.parse(proxy)
+        Net::HTTP::Proxy(uri.host, uri.port, uri.user, uri.password)
+      else
+        proxy.superclass == Net::HTTP ? proxy : Net::HTTP
+      end
+    end
+    protected
+    def send_and_receive(data)
+      httpclient = @http.new(@uri.host, @uri.port)
+      httpclient.open_timeout = @timeout
+      httpclient.read_timeout = @timeout
+      httpclient.use_ssl = (@uri.scheme == 'https')
+      #httpclient.set_debug_output $stderr
+      httpclient.start
+      headers = {'Content-Type' => 'application/hprose',
+                 'Connection' => 'close'}
+      if @keepalive then
+        headers['Connection'] = 'keep-alive'
+        headers['Keep-Alive'] = @keepalive_timeout.to_s
+      end
+      headers['Authorization'] = 'Basic ' << ["#{@uri.user}:#{@uri.password}"].pack('m').delete!("\n") unless @uri.user.nil? or @uri.password.nil?
+      @header.each { |name, value|
+        headers[name] = value
+      }
+      headers['Content-Length'] = data.size.to_s
+      headers['Cookie'] = _get_cookie(@uri.host.downcase, @uri.path, @uri.scheme == 'https')
+      reqpath = @uri.path
+      reqpath << '?' << @uri.query unless @uri.query.nil?
+      response = httpclient.request_post(reqpath, data, headers)
+      case response
+        when Net::HTTPSuccess then
+        cookielist = []
+        cookielist.concat(response['set-cookie'].split(',')) if response.key?('set-cookie')
+        cookielist.concat(response['set-cookie2'].split(',')) if response.key?('set-cookie2')
+        _set_cookie(cookielist, @uri.host.downcase)
+        return response.body
+      else
+        raise Exception.exception(response.message)
+      end
+    end
+    private
+    def _set_cookie(cookielist, host)
+      @@cookie_manager_mutex.synchronize do
+        cookielist.each do |cookies|
+          unless cookies == '' then
+            cookies = cookies.strip.split(';')
+            cookie = {}
+            value = cookies[0].strip.split('=', 2)
+            cookie['name'] = value[0]
+            cookie['value'] = value.size == 2 ? value[1] : ''
+            1.upto(cookies.size - 1) do |i|
+              value = cookies[i].strip.split('=', 2)
+              cookie[value[0].upcase] = value.size == 2 ? value[1] : ''
+            end
+            # Tomcat can return SetCookie2 with path wrapped in "
+            if cookie.has_key?('PATH') then
+              cookie['PATH'][0] = '' if cookie['PATH'][0] == ?"
+              cookie['PATH'].chop! if cookie['PATH'][-1] == ?"
+            else
+              cookie['PATH'] = '/'
+            end
+            cookie['EXPIRES'] = Time.parse(cookie['EXPIRES']) if cookie.has_key?('EXPIRES')
+            cookie['DOMAIN'] = cookie.has_key?('DOMAIN') ? cookie['COMAIN'].downcase : host
+            cookie['SECURE'] = cookie.has_key?('SECURE')
+            @@cookie_manager[cookie['DOMAIN']] = {} unless @@cookie_manager.has_key?(cookie['DOMAIN'])
+            @@cookie_manager[cookie['DOMAIN']][cookie['name']] = cookie
+          end
+        end
+      end
+    end
+    def _get_cookie(host, path, secure)
+      cookies = []
+      @@cookie_manager_mutex.synchronize do
+        @@cookie_manager.each do |domain, cookielist|
+          if host =~ Regexp.new(Regexp.escape(domain) + '$') then
+            names = []
+            cookielist.each do |name, cookie|
+              if cookie.has_key?('EXPIRES') and Time.now <=> cookie['EXPIRES'] > 0 then
+                names << name
+              elsif path =~ Regexp.new('^' + Regexp.escape(cookie['PATH'])) then
+                if ((secure and cookie['SECURE']) or not cookie['SECURE']) and cookie['value'] != '' then
+                  cookies << (cookie['name'] + '=' + cookie['value'])
+                end
+              end
+            end
+            names.each { |name| @@cookie_manager[domain].delete(name) }
+          end
+        end
+      end
+      return cookies.join('; ')
+    end
+  end # class HttpClient
+end # module Hprose

data/lib/hprose/httpservice.rb

@@ -0,0 +1,76 @@
+############################################################
+#                                                          #
+#                          hprose                          #
+#                                                          #
+# Official WebSite: http://www.hprose.com/                 #
+#                   http://www.hprose.net/                 #
+#                   http://www.hprose.org/                 #
+#                                                          #
+############################################################
+
+############################################################
+#                                                          #
+# hprose/httpservice.rb                                    #
+#                                                          #
+# hprose http service for ruby                             #
+#                                                          #
+# LastModified: Mar 8, 2014                                #
+# Author: Ma Bingyao <andot@hprose.com>                    #
+#                                                          #
+############################################################
+
+require "hprose/io"
+require "hprose/service"
+
+module Hprose
+  class HttpService < Service
+    attr_accessor :crossdomain
+    attr_accessor :p3p
+    attr_accessor :get
+    attr_accessor :on_send_header
+    def initialize
+      super
+      @crossdomain = false
+      @p3p = false
+      @get = true
+      @on_send_header = nil
+    end
+    def call(context)
+      header = {'Content-Type' => 'text/plain'}
+      header['P3P'] = 'CP="CAO DSP COR CUR ADM DEV TAI PSA PSD ' +
+        'IVAi IVDi CONi TELo OTPi OUR DELi SAMi OTRi UNRi ' +
+        'PUBi IND PHY ONL UNI PUR FIN COM NAV INT DEM CNT ' +
+        'STA POL HEA PRE GOV"' if @p3p
+      if @crossdomain then
+        origin = context["HTTP_ORIGIN"]
+        if (origin and origin != "null") then
+          header['Access-Control-Allow-Origin'] = origin
+          header['Access-Control-Allow-Credentials'] = 'true'
+        else
+          header['Access-Control-Allow-Origin'] = '*'
+        end
+      end
+      begin
+        statuscode = 200
+        @on_send_header.call(header) unless @on_send_header.nil?
+        if (context['REQUEST_METHOD'] == 'GET') and @get then
+          body = do_function_list
+        elsif (context['REQUEST_METHOD'] == 'POST') then
+          body = handle(context['rack.input'].read, context)
+        else
+          statuscode = 403
+          body = 'Forbidden'
+        end
+      rescue ::Exception => e
+        body = do_error(e)
+      end
+      header['Content-Length'] = body.size.to_s
+      return [statuscode, header, [body]]
+    end
+    protected
+    def fix_args(args, arity, context)
+      session = context['rack.session'] ? context['rack.session'] : {}
+      ((arity > 0) and (args.length + 1 == arity)) ? args + [session] : args
+    end
+  end # class HttpService
+end # module Hprose