hessian2 1.0.3 → 1.1.0

data/README.rdoc

@@ -1,8 +1,6 @@
 = hessian2
 
-hessian客户端。在Christer Sandberg的hessian基础上，修正了pack UTF-8(中文等字符)，指定Long型，更好地被ruby1.9支持。
-
-hessian client. based on Christer Sandberg's hessian, fixed UTF-8 pack, allow declare long type, ruby1.9 tested.
+implement hessian 1.0.2 specification. refactor Christer Sandberg's hessian, ruby 1.9.3 required.
 
 == Using
 
@@ -14,9 +12,10 @@ hessian client. based on Christer Sandberg's hessian, fixed UTF-8 pack, allow de
 
   client = Hessian2::HessianClient.new(url)
   
-  #call remote function: Map<Long, Person> queryPassportUidMap(List<Long> uidList)
-  puts client.queryPassportUidMap([Hessian2::TypeWrapper.new('Long', 47), Hessian2::TypeWrapper.new('Long', 48)])  
-  
+  # call remote function: public Person getPersonByUid(Long uid);
+  uid = Hessian2::TypeWrapper.new('L', 59)
+  puts client.getPersonByUid(uid)
+
 == Authors
 
 * {Takafan}[http://hululuu.com]

data/hessian2.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.email       = ["takafan@163.com"]
   s.homepage    = "http://github.com/takafan/hessian2"
   s.summary     = %q{Hessian2}
-  s.description = %q{hessian client. based on Christer Sandberg's hessian, fixed UTF-8 pack, allow declare long type, ruby1.9 tested.}
+  s.description = %q{implement hessian 1.0.2 specification. refactor Christer Sandberg's hessian, ruby 1.9.3 required.}
 
   s.rubyforge_project = "hessian2"
 

data/lib/hessian2/hessian_client.rb

@@ -0,0 +1,38 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'hessian2/hessian_writer'
+require 'hessian2/hessian_parser'
+
+module Hessian2
+  class HessianClient
+    attr_accessor :user, :password
+    attr_reader :scheme, :host, :port, :path, :proxy
+
+    include HessianWriter
+    include HessianParser
+
+    def initialize(url, proxy = {})
+      uri = URI.parse(url)
+      @scheme, @host, @port, @path = uri.scheme, uri.host, uri.port, uri.path
+      raise "Unsupported Hessian protocol: #{@scheme}" unless %w(http https).include? @scheme
+      @proxy = proxy
+    end
+
+    def method_missing(id, *args)
+      return invoke(id.id2name, args)
+    end
+
+    private
+    def invoke(method, args)
+      req = Net::HTTP::Post.new(@path, { 'Content-Type' => 'application/binary' })
+      req.basic_auth @user, @password if @user
+      conn = Net::HTTP.new(@host, @port, *@proxy.values_at(:host, :port, :user, :password))
+      conn.use_ssl = true and conn.verify_mode = OpenSSL::SSL::VERIFY_NONE if @scheme == 'https'
+      conn.start do |http|
+        parse http.request(req, write_call(method, args)).body
+      end
+    end
+
+  end
+end

data/lib/hessian2/hessian_exception.rb

@@ -0,0 +1,3 @@
+module Hessian2
+  class HessianException < RuntimeError; end
+end

data/lib/hessian2/hessian_parser.rb

@@ -0,0 +1,75 @@
+module Hessian2
+  module HessianParser
+
+    def parse(data, refs = [], chunks = [])
+      t = data.slice!(0)
+      case t
+      when 'r' # reply
+        data.slice!(0, 2)
+        parse(data)
+      when 'f' # fault
+        parse(data)
+        code = parse(data)
+        parse(data)
+        message = parse(data)
+        raise HessianException.new, "#{code}: #{message}"
+      when 'N' # null
+        nil
+      when 'T' # true
+        true
+      when 'F' # false
+        false
+      when 'I' # int
+        data.slice!(0, 4).unpack('l>')[0] 
+      when 'L' # long
+        data.slice!(0, 8).unpack('q>')[0] 
+      when 'D' # double
+        data.slice!(0, 8).unpack('G')[0] 
+      when 'd' # date
+        val = data.slice!(0, 8).unpack('Q>')[0]
+        Time.at(val / 1000, val % 1000 * 1000)
+      when 'S', 's', 'X', 'x' # string, xml
+        len = data.slice!(0, 2).unpack('n')[0]
+
+        chunk = data.unpack("U#{len}")
+        chunks << chunk
+        data.slice!(0, chunk.pack('U*').bytesize)
+        
+        if 'sx'.include?(t)
+          parse(data, refs, chunks)
+        else
+          chunks.flatten.pack('U*')
+        end
+      when 'B', 'b' # binary
+        len = data.slice!(0, 2).unpack('n')[0]
+
+        chunk = data.slice!(0, len)
+        chunks << chunk
+        
+        if t == 'b'
+          parse(data, refs, chunks)
+        else
+          chunks.flatten 
+        end
+      when 'V' # list
+        data.slice!(0, 3 + data.unpack('an')[1]) if data[0] == 't'
+        data.slice!(0, 5) if data[0] == 'l'
+        refs << (list = [])
+        list << parse(data, refs) while data[0] != 'z'
+        data.slice!(0)
+        list
+      when 'M' # map
+        data.slice!(0, 3 + data.unpack('an')[1]) if data[0] == 't'
+        refs << (map = {})
+        map[parse(data, refs)] = parse(data, refs) while data[0] != 'z'
+        data.slice!(0)
+        map
+      when 'R' # ref
+        refs[data.slice!(0, 4).unpack('N')[0]]
+      else
+        raise HessianException.new, "Invalid type: '#{t}'"
+      end
+    end
+
+  end 
+end

data/lib/hessian2/hessian_writer.rb

@@ -0,0 +1,130 @@
+module Hessian2
+  module HessianWriter
+    CHUNK_SIZE = 32768
+
+    def write_call(method, args)
+      refs = {}
+      out = [ 'c', '0', '1', 'm', method.length ].pack('ahhan') << method
+      args.each { |arg| out << write(arg, refs) }
+      out << 'z'
+    end
+
+    private
+    def write(val, refs = {}, chunks = [], type = nil)
+      case val
+      when TypeWrapper
+        obj, hessian_type = val.object, val.hessian_type
+        case hessian_type
+        when 'L', 'Long', 'long'  # declare as long
+          [ 'L', obj ].pack('aq>')  # long
+        when 'X', 'x' # declare as xml
+          if obj.size > CHUNK_SIZE
+            chunk = obj.slice!(0, CHUNK_SIZE)
+            if chunk.ascii_only?
+              chunks << [ 's', CHUNK_SIZE ].pack('an') << chunk
+            else
+              chunks << [ 's', CHUNK_SIZE, chunk.unpack('U*') ].flatten.pack('anU*')
+            end
+            write(TypeWrapper.new('X', obj), refs, chunks)
+          else
+            if obj.bytesize == obj.size
+              chunks << [ 'X', obj.size ].pack('an') << obj
+            else
+              chunks << [ 'X', obj.size, obj.unpack('U*') ].flatten.pack('anU*')
+            end
+            chunks.join # xml
+          end
+        when 'B', 'b' # declare as binary
+          [ 'B', obj.size ].pack('an') << obj
+          if obj.size > CHUNK_SIZE
+            chunk = obj.slice!(0, CHUNK_SIZE)
+            chunks << [ 'b', CHUNK_SIZE ].pack('an') << chunk
+            write(TypeWrapper.new('B', obj), refs, chunks)
+          else
+            chunks << [ 'B', obj.size ].pack('an') << obj
+            chunks.join # binary
+          end
+        else  # type for list, map
+          write(obj, refs, chunks, hessian_type)
+        end
+      when NilClass
+        'N' # null
+      when TrueClass
+        'T' # true
+      when FalseClass
+        'F' # false
+      when Fixnum
+        [ 'I', val ].pack('al>')  # int
+      when Bignum
+        [ 'L', val ].pack('aq>')  # long
+      when Float
+        [ 'D', val ].pack('aG') # double
+      when Time
+        [ 'd', val.to_f * 1000 ].pack('aQ>')  # date
+      when String
+        if val.size > CHUNK_SIZE
+          chunk = val.slice!(0, CHUNK_SIZE)
+          if chunk.ascii_only?
+            chunks << [ 's', CHUNK_SIZE ].pack('an') << chunk
+          else
+            # unpack-pack if chunk incompatible with ASCII-8BIT
+            chunks << [ 's', CHUNK_SIZE, chunk.unpack('U*') ].flatten.pack('anU*')
+          end
+          write(val, refs, chunks)
+        else
+          if val.bytesize == val.size
+            chunks << [ 'S', val.size ].pack('an') << val
+          else
+            chunks << [ 'S', val.size, val.unpack('U*') ].flatten.pack('anU*')
+          end
+          chunks.join # string
+        end
+      when Symbol
+        str = val.to_s
+        [ 'S', str.size ].pack('an') << str # string
+      when Array
+        id = refs[val.object_id]
+        return [ 'R', id ].pack('aN') if id
+
+        refs[val.object_id] = refs.size
+      
+        str = 'V'
+        str << 't' << [ type.size, type ].pack('na*') if type
+        str << 'l' << [ val.size ].pack('N')
+        val.each{ |v| str << write(v, refs) }
+        str << 'z'  # list
+      when Hash
+        id = refs[val.object_id]
+        return [ 'R', id ].pack('aN') if id 
+        
+        refs[val.object_id] = refs.size
+
+        str = 'M'
+        str << 't' << [ type.size, type ].pack('na*') if type
+        val.each do |k, v|
+          str << write(k, refs)
+          str << write(v, refs)
+        end
+        str << 'z'  # map
+      else  # covert val to hash
+        hash = {}.tap do |h| 
+          val.instance_variables.each {|var| h[var.to_s.delete("@")] = val.instance_variable_get(var) }
+        end
+
+        unless type 
+          # map ruby module to java package
+          arr = val.class.to_s.split('::')
+          if arr.size > 1
+            klass = arr.pop
+            type = arr.map{|m| m.downcase}.join('.') << ".#{klass}"
+          else
+            type = arr.first
+          end
+        end
+
+        write(hash, refs, chunks, type)
+      end
+    end
+
+  end
+end

data/lib/hessian2/type_wrapper.rb

@@ -0,0 +1,8 @@
+module Hessian2
+  class TypeWrapper
+    attr_accessor :hessian_type, :object
+    def initialize(hessian_type, object)
+      @hessian_type, @object = hessian_type, object
+    end
+  end
+end

data/lib/hessian2/version.rb

@@ -1,3 +1,3 @@
 module Hessian2
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/lib/hessian2.rb

@@ -1,231 +1,6 @@
-require "hessian2/version"
-
-require 'uri'
-require 'net/http'
-require 'net/https'
-
-module Hessian2
-  class TypeWrapper
-    attr_accessor :hessian_type, :object
-    def initialize(hessian_type, object)
-      @hessian_type, @object = hessian_type, object
-    end
-  end
-  
-  class Binary
-    attr :data
-    def initialize(data)
-      @data = data.to_s
-    end
-  end
-
-  class HessianException < RuntimeError
-    attr_reader :code
-    def initialize(code)
-      @code = code
-    end
-  end
-
-  class HessianClient
-    attr_accessor :user, :password
-    attr_reader :scheme, :host, :port, :path, :proxy
-    def initialize(url, proxy = {})
-      uri = URI.parse(url)
-      @scheme, @host, @port, @path = uri.scheme, uri.host, uri.port, uri.path
-      raise "Unsupported Hessian protocol: #@scheme" unless @scheme == 'http' || @scheme == 'https'
-      @proxy = proxy
-    end
-    
-    def method_missing(id, *args)
-      return invoke(id.id2name, args)
-    end
-
-    private
-    def invoke(method, args)
-      call = HessianWriter.new.write_call method, args
-      header = { 'Content-Type' => 'application/binary' }
-      req = Net::HTTP::Post.new(@path, header)
-      req.basic_auth @user, @password if @user
-      conn = Net::HTTP.new(@host, @port, *@proxy.values_at(:host, :port, :user, :password))
-      conn.use_ssl = true and conn.verify_mode = OpenSSL::SSL::VERIFY_NONE if @scheme == 'https'
-      conn.start do |http|
-        res = http.request(req, call)
-        HessianParser.new.parse_response res.body
-      end
-    end
-
-    class HessianWriter
-      def write_call(method, args)
-        @refs = {}
-        out = [ 'c', '0', '1', 'm', method.length ].pack('ahhan') << method
-        args.each { |arg| out << write_object(arg) }
-        out << 'z'
-      end
-
-      private
-      def write_object(val, hessian_type = nil)
-        return 'N' if val.nil?
-        case val
-        when TypeWrapper
-          val.hessian_type == 'Long' ? "L%s" % to_long(val.object) : write_object(val.object, val.hessian_type)
-        when Struct
-          write_object(val.members.inject({}) { |map, m| map[m] = val[m]; map })
-        when Binary
-          [ 'B', val.data.length ].pack('an') << val.data
-        when String
-          [ 'S', val.length ].pack('an') << val.unpack('U*').pack('U*')
-        when
-          Integer
-          # Max and min values for integers in Java.
-          if val >= -0x80000000 && val <= 0x7fffffff
-            [ 'I', val ].pack('aN')
-          else
-            "L%s" % to_long(val)
-          end
-        when Float
-          [ 'D', val ].pack('aG')
-        when Time
-          "d%s" % to_long((val.to_f * 1000).to_i)
-        when TrueClass
-          'T'
-        when FalseClass
-          'F'
-        when Array
-          ref = write_ref val; return ref if ref
-          t = hessian_type_string(hessian_type, val)
-          str = 'Vt' << t << 'l' << [ val.length ].pack('N')
-          val.each { |v| str << write_object(v) }
-          str << 'z'
-        when Hash
-          ref = write_ref val; return ref if ref
-          str = 'Mt' << hessian_type_string(hessian_type, val)
-          val.each { |k, v| str << write_object(k); str << write_object(v) }
-          str << 'z'
-        else
-          raise "Not implemented for #{val.class}"
-        end
-      end
-      
-      def hessian_type_string(hessian_type, object)
-        if hessian_type.nil? && object.respond_to?(:hessian_type)
-          hessian_type = object.hessian_type
-        end        
-        hessian_type ? [ hessian_type.length, hessian_type ].pack('na*') : "\000\000"
-      end
-      
-      def to_long(val)
-        val2 = val.to_s(2)
-        ['0' * (64 - val2.size) << val2].pack("B*")
-      end
-
-      def write_ref(val)
-        id = @refs[val.object_id]
-        if id
-          [ 'R', id ].pack('aN')
-        else
-          @refs[val.object_id] = @refs.length
-          nil
-        end
-      end
-    end
-
-    class HessianParser
-      def parse_response(res)
-        raise "Invalid response, expected 'r', received '#{res[0,1]}'" unless res[0,1] == 'r'
-        @chunks = []
-        @refs = []
-        @data = res[3..-1]
-        parse_object
-      end
-
-      private
-      def parse_object
-        t = @data.slice!(0, 1)
-        
-        case t
-        when 'f'
-            raise_exception
-        when 's', 'S', 'x', 'X'
-          
-          v = from_utf8(@data.slice!(0, 2).unpack('n')[0])
-          @data.slice!(0, v[1])
-          @chunks << v[0]
-          
-          if 'sx'.include? t
-            
-            parse_object
-          else
-            str = @chunks.join; @chunks.clear; str
-          end
-        when 'b', 'B'
-          v = @data.slice!(0, @data.slice!(0, 2).unpack('n')[0])
-          @chunks << v
-          if t == 'b'
-            parse_object
-          else
-            bytes = @chunks.join; @chunks.clear; Binary.new bytes
-          end
-        when 'I'
-          @data.slice!(0, 4).unpack('N')[0]
-        when 'L'
-          parse_long
-        when 'd'
-           l = parse_long; Time.at(l / 1000, l % 1000 * 1000)
-        when 'D'
-           @data.slice!(0, 8).unpack('G')[0]
-        when 'T'
-          true
-        when 'F'
-          false
-        when 'N'
-          nil
-        when 'R'
-          @refs[@data.slice!(0, 4).unpack('N')[0]]
-        when 'V'
-          # Skip type + type length (2 bytes) if specified.
-          @data.slice!(0, 3 + @data.unpack('an')[1]) if @data[0,1] == 't'
-          # Skip the list length if specified.
-          @data.slice!(0, 5) if @data[0,1] == 'l'
-          @refs << (list = [])
-          list << parse_object while @data[0,1] != 'z'
-          # Get rid of the 'z'.
-          @data.slice!(0, 1)
-          list
-        when 'M'
-          # Skip type + type length (2 bytes) if specified.
-          @data.slice!(0, 3 + @data.unpack('an')[1]) if @data[0,1] == 't'
-          @refs << (map = {})
-          map[parse_object()] = parse_object while @data[0,1] != 'z'
-          # Get rid of the 'z'.
-          @data.slice!(0, 1)
-          map
-        else
-          puts @data
-          raise "Invalid type: '#{t}'"
-        end
-      end
-      
-      def from_utf8(len = '*')
-        s = @data.unpack("U#{len}").pack('U*')
-        [ s, s.unpack('C*').pack('U*').length ]
-      end
-
-      def parse_long
-        val, o = 0, 56
-        @data.slice!(0, 8).each_byte { |b| val += (b & 0xff) << o; o -= 8 }
-        val
-      end
-
-      def raise_exception
-        # Skip code description.
-        parse_object
-        code = parse_object
-        # Skip message description
-        parse_object
-        msg = parse_object
-        raise HessianException.new(code), msg
-      end
-    end
-  end
-end
+# http://hessian.caucho.com/doc/hessian-1.0-spec.xtp
 
+require "hessian2/version"
+require 'hessian2/hessian_client'
+require 'hessian2/type_wrapper'
+require 'hessian2/hessian_exception'

data/test/test_hessian_parser.rb

@@ -4,9 +4,8 @@ require 'hessian2'
 require 'test/unit'
 
 class HessianParserTest < Test::Unit::TestCase
-  def parse res
-    Hessian2::HessianClient::HessianParser.new.parse_response res
-  end
+  
+  include  Hessian2::HessianParser
   
   def test_integer
     assert_equal 4711, parse("r\001\000I\000\000\022gz")
@@ -53,5 +52,5 @@ class HessianParserTest < Test::Unit::TestCase
     assert_equal map, parse([ "r\001\000Mt\000\000S\000\anumbersVt\000\a[double",
       "l\000\000\000\003D?\361\231\231\231\231\231\232D?\363333333D?",
       "\364\314\314\314\314\314\315zS\000\006sillenI\000\000\000 zz" ].join)
-    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hessian2
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-12 00:00:00.000000000 Z
+date: 2012-12-08 00:00:00.000000000 Z
 dependencies: []
-description: hessian client. based on Christer Sandberg's hessian, fixed UTF-8 pack,
-  allow declare long type, ruby1.9 tested.
+description: implement hessian 1.0.2 specification. refactor Christer Sandberg's hessian,
+  ruby 1.9.3 required.
 email:
 - takafan@163.com
 executables: []
@@ -25,8 +25,12 @@ files:
 - Rakefile
 - hessian2.gemspec
 - lib/hessian2.rb
+- lib/hessian2/hessian_client.rb
+- lib/hessian2/hessian_exception.rb
+- lib/hessian2/hessian_parser.rb
+- lib/hessian2/hessian_writer.rb
+- lib/hessian2/type_wrapper.rb
 - lib/hessian2/version.rb
-- test/servlet_invoker.rb
 - test/test_hessian_parser.rb
 homepage: http://github.com/takafan/hessian2
 licenses: []

data/test/servlet_invoker.rb

@@ -1,17 +0,0 @@
-require 'net/http'
-
-HEADER = { 'Content-Type' => 'application/binary' }
-
-call = %w(c 0 1 m).pack('ahha')
-methods = %w(
-  getInt getLong getDouble getFalse getTrue getString getNull
-  getDate getIntArray getObjectArray getArrayInList getMap
-)
-
-methods.each do |m|
-  Net::HTTP.start('localhost', 8080) do |http|
-    res = http.send_request('POST', '/test',
-      call + [ m.length, m ].pack('na*') + 'z', HEADER)
-    p res.body
-  end
-end