hessian2 1.1.1 → 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 453a51289b1c88074aa15ecbf5018cbece6297b5
+  data.tar.gz: 071db1c35b766485e0789ab22395769ac63cf652
+SHA512:
+  metadata.gz: fd9256a1475ed060499bed2a415eca1eb2bfdb20d1a315935f93dfdd2bb5090bead4ff0820df0f106e8534c34b4e54cbebcf8abc10232d31647040247777fca2
+  data.tar.gz: 6624cba7d4093cec93d94d14a1dd82a5b39bce2340a6a229a0eaf4e045e88d2e5a29eeec03d8ad29c7b103841820939b13233433a40bf0332c3cc25ca4e26991

data/.gitignore

@@ -1,6 +1,10 @@
 *.gem
 .bundle
 Gemfile.lock
+doc/*
 pkg/*
-*.komodoproject
-.idea/
+spec/*.yml
+spec/*.jpg
+test/*.data
+test/*.txt
+test/*.yml

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 takafan
+
+MIT License
+
+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.md

@@ -0,0 +1,161 @@
+# hessian2
+
+like json, additionally, 麻绳2 parse your object as a struct.
+
+hessian2 implements hessian 2.0 protocol. look [web services protocol](http://hessian.caucho.com/doc/hessian-ws.html) and [serialization protocol](http://hessian.caucho.com/doc/hessian-serialization.html).
+
+## comparing
+
+yajl-ruby: json, fast.
+
+msgpack: binary, faster.
+
+protobuf: encoding your object with schema.
+
+marshal: powerful, fast, but ruby only.
+
+hessian2: powerful as marshal but parse object to struct, clean api, smaller.
+
+## install
+
+```
+gem install hessian2
+```
+
+## serializing
+
+```
+require 'hessian2'
+```
+
+``` ruby
+attributes = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+monkey = Monkey.new(attributes)
+#=> #<Monkey id: nil, born_at: "2009-05-08 00:00:00", name: "\u5927\u9E21", price: #<BigDecimal:2b7c568,'0.9998999999 999999E2',27(45)>>
+
+bin = Hessian2.write(monkey)
+```
+
+## deserializing 
+
+``` ruby
+monkey = Hessian2.parse(bin)
+#=> #<struct id=nil, born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21", price=99.99>
+```
+
+## struct wrapper 
+
+for hash and object, only send values that specified.
+
+``` ruby
+MonkeyStruct = Struct.new(:born_at, :name)
+
+wrapped_monkey = Hessian2::StructWrapper.new(MonkeyStruct, monkey)
+bin = Hessian2.write(wrapped_monkey)
+```
+
+parsing values-binary to a monkey struct
+
+``` ruby
+monkey = Hessian2.parse(bin, MonkeyStruct)
+#=> #<struct born_at=2009-05-08 00:00:00 +0800, name="\u5927\u9E21">
+```
+
+monkeys
+
+``` ruby
+wrapped_monkeys = Hessian2::StructWrapper.new([MonkeyStruct], monkeys)
+bin = Hessian2.write(wrapped_monkeys)
+
+monkeys = Hessian2.parse(bin, [MonkeyStruct])
+```
+
+struct wrapper supports: hash, object, [hash, [object
+
+## class wrapper
+
+for statically typed languages.
+
+``` ruby
+wrapped_monkey = Hessian2::ClassWrapper.new('com.sun.java.Monkey', monkey)
+```
+
+monkeys
+
+``` ruby
+wrapped_monkeys = Hessian2::ClassWrapper.new('[com.sun.java.Monkey', monkeys)
+```
+
+class wrapper supports: hash, object, [hash, [object
+
+## type wrapper
+
+wrap a string to long
+
+``` ruby
+str = '-0x8_000_000_000_000_000'
+heslong = Hessian2::TypeWrapper.new(:long, str)
+```
+
+wrap a file to binary
+
+``` ruby
+binstr = IO.binread(File.expand_path("../Lighthouse.jpg", __FILE__))
+hesbin = Hessian2::TypeWrapper.new(:bin, binstr)
+```
+
+there are types: 'L', 'I', 'B', '[L', '[I', '[B', :long, :int, :bin, [:long], [:int], [:bin]
+
+## :symbolize_keys parser option
+
+``` ruby
+bin = Hessian2.write(attributes)
+hash = Hessian2.parse(bin, nil, symbolize_keys: true)
+#=> {:born_at=>2009-05-08 00:00:00 +0800, :name=>"\u5927\u9E21", :price=>99.99}
+```
+
+## client
+
+``` ruby
+url = 'http://127.0.0.1:9292/monkey'
+client = Hessian2::Client.new(url)
+```
+
+call remote method, send a monkey
+
+``` ruby
+client.send_monkey(monkey)
+```
+
+## service
+
+extend hessian handler
+
+``` ruby
+class MonkeyService
+  extend Hessian2::Handler
+
+  def self.send_monkey(monkey)
+  # ...
+end
+```
+
+handle request
+
+``` ruby
+post '/monkey' do
+  MonkeyService.handle(request.body.read)
+end
+```
+
+## todo
+
+on linux string slower than thrift
+
+supports packet and envelope
+
+write in c
+
+## authors
+
+[takafan](http://hululuu.com)

data/hessian2.gemspec

@@ -9,9 +9,10 @@ Gem::Specification.new do |s|
   s.email       = ["takafan@163.com"]
   s.homepage    = "http://github.com/takafan/hessian2"
   s.summary     = %q{Hessian2}
-  s.description = %q{implement hessian 1.0.2 specification. refactor Christer Sandberg's hessian, ruby 1.9.3 required.}
+  s.description = %q{like json, additionally, 麻绳2 parse your object as a struct.}
 
   s.rubyforge_project = "hessian2"
+  s.license = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -20,5 +21,5 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "bigdecimal"
 end

data/lib/hessian2.rb

@@ -1,6 +1,14 @@
-# http://hessian.caucho.com/doc/hessian-1.0-spec.xtp
-
-require "hessian2/version"
+require 'hessian2/class_wrapper'
+require 'hessian2/client'
+require 'hessian2/fault'
+require 'hessian2/handler'
 require 'hessian2/hessian_client'
+require 'hessian2/parser'
+require 'hessian2/struct_wrapper'
 require 'hessian2/type_wrapper'
-require 'hessian2/hessian_exception'
+require 'hessian2/version'
+require 'hessian2/writer'
+
+module Hessian2
+  extend Parser, Writer
+end

data/lib/hessian2/class_wrapper.rb

@@ -0,0 +1,89 @@
+module Hessian2
+  class ClassWrapper
+    attr_reader :klass, :fields, :values, :is_multi
+
+    def initialize(klass, object)
+    	raise 'klass should not be nil' unless klass
+      
+      if klass.include?('[')
+      	is_multi = true
+	      klass.delete!('[]')
+
+      	sample = object.select{|x| x}.first
+        unless sample # all nil
+	      	values = [ nil ] * object.size
+	      else
+	      	fields = if sample.is_a?(Hash)
+		      	sample.keys.map{|k| k.to_sym }
+		      elsif sample.instance_variable_get(:@attributes).is_a?(Hash)
+		      	sample.attributes.keys.map{|k| k.to_sym }
+          elsif sample.is_a?(ClassWrapper)
+            sample.fields
+          elsif sample.is_a?(TypeWrapper)
+            sample.object.keys.map{|k| k.to_sym }
+		      else
+		      	sample.instance_variables.map{|k| k[1..-1].to_sym }
+		      end
+
+		      raise "fields should not be empty: #{object.inspect}" if fields.empty?
+
+		      values = object.map do |obj|
+		      	if obj.nil?
+		      		nil
+		      	elsif obj.is_a?(Hash)
+			        fields.map{|f| obj[f] || obj[f.to_s] }
+			      elsif obj.instance_variable_get(:@attributes).is_a?(Hash)
+			        fields.map{|f| obj.attributes[f.to_s] }
+            elsif obj.is_a?(ClassWrapper)
+              obj.values
+            elsif obj.is_a?(TypeWrapper)
+              fields.map{|f| obj.object[f] || obj.object[f.to_s] }
+			      else
+			        fields.map{|f| obj.instance_variable_get(f.to_s.prepend('@')) }
+			      end
+		      end
+	      end
+	    else
+	    	is_multi = false
+
+	    	if object
+	    		fields, values = [], []
+		    	if object.is_a?(Hash)
+		        object.each do |k, v|
+		        	fields << k.to_sym
+		        	values << v
+		        end
+		      elsif object.instance_variable_get(:@attributes).is_a?(Hash)
+		        object.attributes.each do |k, v|
+		        	fields << k.to_sym
+		        	values << v
+		        end
+          elsif object.is_a?(ClassWrapper)
+            fields, values = object.fields, object.values
+          elsif object.is_a?(TypeWrapper)
+            object.object.each do |k, v|
+              fields << k.to_sym
+              values << v
+            end
+		      else
+		        object.instance_variables.each do |var|
+		        	k = var[1..-1]
+		        	fields << k.to_sym
+		        	values << object.instance_variable_get(k.prepend('@'))
+		        end
+		      end
+
+		      raise "fields should not be empty: #{object.inspect}" if fields.empty?
+		    end
+	    end
+
+      @klass, @fields, @values, @is_multi = klass, fields, values, is_multi 
+    end
+
+
+    def is_multi?
+    	@is_multi
+    end
+
+  end
+end

data/lib/hessian2/client.rb

@@ -0,0 +1,38 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'hessian2'
+
+module Hessian2
+  class Client
+    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.empty? ? '/' : uri.path
+      @path += "?#{uri.query}" if uri.query
+      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|
+        Hessian2.parse_rpc(http.request(req, Hessian2.call(method, args)).body)
+      end
+    end
+
+  end
+end

data/lib/hessian2/constants.rb

@@ -0,0 +1,164 @@
+module Hessian2
+  #=== Hessian 2.0 Web Services Protocol Bytecode map
+  #
+  #   x00 - x42    # reserved
+  #   x43          # rpc call ('C')
+  #   x44          # reserved
+  #   x45          # envelope ('E')
+  #   x46          # fault ('F')
+  #   x47          # reserved
+  #   x48          # hessian version ('H')
+  #   x49 - x4f    # reserved
+  #   x4f          # packet chunk ('O')
+  #   x50          # packet end ('P')
+  #   x51          # reserved
+  #   x52          # rpc result ('R')
+  #   x53 - x59    # reserved
+  #   x5a          # terminator ('Z')
+  #   x5b - x5f    # reserved
+  #   x70 - x7f    # final packet (0 - 4096)
+  #   x80 - xff    # final packet for envelope (0 - 127)
+  #
+  #=== Hessian 2.0 Serialization Protocol Bytecode map
+  #
+  #   x00 - x1f    # utf-8 string length 0-31*
+  #   x20 - x2f    # binary data length 0-15*
+  #   x30 - x33    # utf-8 string length 0-1023
+  #   x34 - x37    # binary data length 0-1023
+  #   x38 - x3f    # three-octet compact long (-x40000 to x3ffff)
+  #   x40          # reserved (expansion/escape)
+  #   x41          # 8-bit binary data non-final chunk ('A')
+  #   x42          # 8-bit binary data final chunk ('B')
+  #   x43          # object type definition ('C')
+  #   x44          # 64-bit IEEE encoded double ('D')
+  #   x45          # reserved
+  #   x46          # boolean false ('F')
+  #   x47          # reserved
+  #   x48          # untyped map ('H')
+  #   x49          # 32-bit signed integer ('I')
+  #   x4a          # 64-bit UTC millisecond date
+  #   x4b          # 32-bit UTC minute date
+  #   x4c          # 64-bit signed long integer ('L')
+  #   x4d          # map with type ('M')
+  #   x4e          # null ('N')
+  #   x4f          # object instance ('O')
+  #   x50          # reserved
+  #   x51          # reference to map/list/object - integer ('Q')
+  #   x52          # utf-8 string non-final chunk ('R')
+  #   x53          # utf-8 string final chunk ('S')
+  #   x54          # boolean true ('T')
+  #   x55          # variable-length list/vector ('U')
+  #   x56          # fixed-length list/vector ('V')
+  #   x57          # variable-length untyped list/vector ('W')
+  #   x58          # fixed-length untyped list/vector ('X')
+  #   x59          # long encoded as 32-bit int ('Y')
+  #   x5a          # list/map terminator ('Z')
+  #   x5b          # double 0.0
+  #   x5c          # double 1.0
+  #   x5d          # double represented as byte (-128.0 to 127.0)
+  #   x5e          # double represented as short (-32768.0 to 32767.0)
+  #   x5f          # double represented as float
+  #   x60 - x6f    # object with direct type
+  #   x70 - x77    # fixed list with direct length
+  #   x78 - x7f    # fixed untyped list with direct length
+  #   x80 - xbf    # one-octet compact int (-x10 to x2f, x90 is 0)*
+  #   xc0 - xcf    # two-octet compact int (-x800 to x7ff)
+  #   xd0 - xd7    # three-octet compact int (-x40000 to x3ffff)
+  #   xd8 - xef    # one-octet compact long (-x8 to xf, xe0 is 0)
+  #   xf0 - xff    # two-octet compact long (-x800 to x7ff, xf8 is 0)
+  module Constants
+    BC_BINARY = 0x42
+    BC_BINARY_CHUNK = 0x41
+    BC_BINARY_DIRECT = 0x20
+    BINARY_DIRECT_MAX = 0x0f
+    BC_BINARY_SHORT = 0x34
+    BINARY_SHORT_MAX = 0x3ff
+
+    BC_CLASS_DEF = 0x43
+
+    BC_DATE = 0x4a
+    BC_DATE_MINUTE = 0x4b
+    
+    BC_DOUBLE = 0x44
+
+    BC_DOUBLE_ZERO = 0x5b
+    BC_DOUBLE_ONE = 0x5c
+    BC_DOUBLE_BYTE = 0x5d
+    BC_DOUBLE_SHORT = 0x5e
+    BC_DOUBLE_MILL = 0x5f
+    
+    BC_FALSE = 0x46
+    
+    BC_INT = 0x49
+    
+    INT_DIRECT_MIN = -0x10
+    INT_DIRECT_MAX = 0x2f
+    BC_INT_ZERO = 0x90
+
+    INT_BYTE_MIN = -0x800
+    INT_BYTE_MAX = 0x7ff
+    BC_INT_BYTE_ZERO = 0xc8
+    
+    BC_END = 0x5a
+
+    INT_SHORT_MIN = -0x40000
+    INT_SHORT_MAX = 0x3ffff
+    BC_INT_SHORT_ZERO = 0xd4
+
+    BC_LIST_VARIABLE = 0x55
+    BC_LIST_FIXED = 0x56
+    BC_LIST_VARIABLE_UNTYPED = 0x57
+    BC_LIST_FIXED_UNTYPED = 0x58
+
+    BC_LIST_DIRECT = 0x70
+    BC_LIST_DIRECT_UNTYPED = 0x78
+    LIST_DIRECT_MAX = 0x7
+
+    BC_LONG = 0x4c
+    LONG_DIRECT_MIN = -0x08
+    LONG_DIRECT_MAX =  0x0f
+    BC_LONG_ZERO = 0xe0
+
+    LONG_BYTE_MIN = -0x800
+    LONG_BYTE_MAX =  0x7ff
+    BC_LONG_BYTE_ZERO = 0xf8
+
+    LONG_SHORT_MIN = -0x40000
+    LONG_SHORT_MAX = 0x3ffff
+    BC_LONG_SHORT_ZERO = 0x3c
+    
+    BC_LONG_INT = 0x59
+    
+    BC_MAP = 0x4d
+    BC_MAP_UNTYPED = 0x48
+    
+    BC_NULL = 0x4e
+    
+    BC_OBJECT = 0x4f
+    BC_OBJECT_DEF = 0x43
+    
+    BC_OBJECT_DIRECT = 0x60
+    OBJECT_DIRECT_MAX = 0x0f
+    
+    BC_REF = 0x51
+
+    BC_STRING = 0x53
+    BC_STRING_CHUNK = 0x52
+    
+    BC_STRING_DIRECT = 0x00
+    STRING_DIRECT_MAX = 0x1f
+    BC_STRING_SHORT = 0x30
+    STRING_SHORT_MAX = 0x3ff
+    
+    BC_TRUE = 0x54
+
+    P_PACKET_CHUNK = 0x4f
+    P_PACKET = 0x50
+
+    P_PACKET_DIRECT = 0x80
+    PACKET_DIRECT_MAX = 0x7f
+
+    P_PACKET_SHORT = 0x70
+    PACKET_SHORT_MAX = 0xfff
+  end
+end