hessian2 1.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.komodoproject
+.idea/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hessian2.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,22 @@
+= 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.
+
+== Using
+
+  gem install hessian2
+
+  require 'hessian2'
+
+  url = 'http://localhost:8080/person_service'
+
+  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)])  
+  
+== Authors
+
+* {Takafan}[http://hululuu.com]

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/hessian2.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hessian2/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hessian2"
+  s.version     = Hessian2::VERSION
+  s.authors     = ["takafan"]
+  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.rubyforge_project = "hessian2"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/hessian2/version.rb

@@ -0,0 +1,3 @@
+module Hessian2
+  VERSION = "1.0.2"
+end

data/lib/hessian2.rb

@@ -0,0 +1,231 @@
+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('C*').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
+

data/test/servlet_invoker.rb

@@ -0,0 +1,17 @@
+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

data/test/test_hessian_parser.rb

@@ -0,0 +1,57 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+require 'hessian2'
+require 'test/unit'
+
+class HessianParserTest < Test::Unit::TestCase
+  def parse res
+    Hessian2::HessianClient::HessianParser.new.parse_response res
+  end
+  
+  def test_integer
+    assert_equal 4711, parse("r\001\000I\000\000\022gz")
+  end
+  def test_long
+    assert_equal 2, parse("r\001\000L\000\000\000\000\000\000\000\002z")
+  end  
+  def test_double
+    assert_equal 3.4, parse("r\001\000D@\v333333z")
+  end
+  def test_false
+    assert_equal false, parse("r\001\000Fz")
+  end
+  def test_true
+    assert_equal true, parse("r\001\000Tz")
+  end
+  def test_string
+    assert_equal "string", parse("r\001\000S\000\006stringz")
+  end
+  def test_null
+    assert_equal nil, parse("r\001\000Nz")
+  end
+  def test_date
+    time = parse("r\001\000d\000\000\001\010\344\036\332\360z")
+    assert_instance_of Time, time
+    assert_equal '2006-01-19 19:23:13', time.getutc.strftime("%Y-%m-%d %H:%M:%S")
+    assert_equal 520000, time.usec
+  end
+  def test_integer_array
+    assert_equal [ 1, 2, 3 ], parse([ "r\001\000Vt\000\004[intl\000\000\000\003",
+      "I\000\000\000\001I\000\000\000\002I\000\000\000\003zz" ].join)
+  end
+  def test_array
+    assert_equal [ 'sillen', 32 ], parse([ "r\001\000Vt\000\a[objectl\000\000\000\002",
+      "S\000\006sillenI\000\000\000 zz" ].join)
+  end
+  def test_array_in_array
+    assert_equal [ 'A list', [ 9, 3 ] ], parse([ "r\001\000Vl\000\000\000\002S\000\006",
+      "A listVt\000\022[java.lang.Integerl\000\000\000\002I\000\000\000\t",
+      "I\000\000\000\003zzz" ].join)
+  end
+  def test_map
+    map = { 'sillen' => 32, 'numbers' => [ 1.1, 1.2, 1.3 ] }
+    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

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: hessian2
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+  prerelease: 
+platform: ruby
+authors:
+- takafan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-24 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.
+email:
+- takafan@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- hessian2.gemspec
+- lib/hessian2.rb
+- lib/hessian2/version.rb
+- test/servlet_invoker.rb
+- test/test_hessian_parser.rb
+homepage: http://github.com/takafan/hessian2
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: hessian2
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Hessian2
+test_files:
+- test/servlet_invoker.rb
+- test/test_hessian_parser.rb