em_hessian2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f86a3f73d4a240f7d3a6d4ebd13357be4e1d6ebe
+  data.tar.gz: ffd3bfa2567ebe5bad5991338109ec0b4f53400b
+SHA512:
+  metadata.gz: 87dc2b7e7b3c45dccad5b1f4cb126eba30dbebbc410aad62e55be4022eaf13fc7d3ec3e314beb9ad68acb6809b1f500d7139b5ec7a401bd0ff14b8a00f0a5d93
+  data.tar.gz: f3be7a27ba419b4a28826d75a1175686f254bd1cc646a134e04612ef4f5943ba972d9c5930b35162ee99bf4270a9525be6bf5de39609ffc80e09566a00e17549

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+doc/*
+pkg/*
+test/*.data
+test/*.txt
+test/*.yml

data/Gemfile

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

data/README.md

@@ -0,0 +1,186 @@
+# hessian2
+
+like json, additionally, 麻绳2 support structured data, with no schema.
+
+hessian2 implements hessian 2.0 protocol. check [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 structured data 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
+monkey = Monkey.new(born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99)
+#=> #<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=(7036170730324623/70368744177664)>
+```
+
+## 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]
+
+## 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 in sinatra
+
+``` ruby
+post '/monkey' do
+  MonkeyService.handle(request.body.read)
+end
+```
+
+## test
+
+```
+cd test/
+```
+
+start a service
+
+```
+ruby ./app.rb -o 0.0.0.0 -e production
+```
+
+or
+
+```
+thin start -p 4567 --threaded -e production 
+```
+
+test parser
+
+```
+ruby ./get.rb
+```
+
+test writer
+
+```
+ruby ./set.rb
+```
+
+## todo
+
+supports packet and envelope
+
+rsa aes encryption
+
+write in c
+
+## authors
+
+[takafan](http://hululuu.com)
+
+## license
+
+[Ruby License](http://www.ruby-lang.org/en/LICENSE.txt)

data/Rakefile

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

data/hessian2.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hessian2/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em_hessian2"
+  s.version     = Hessian2::VERSION
+  s.authors     = ["takafan", "ldd600"]
+  s.email       = ["takafan@163.com"]
+  s.homepage    = "http://github.com/takafan/hessian2"
+  s.summary     = %q{Hessian2}
+  s.description = %q{json encode fast, hessian write small.}
+
+  s.rubyforge_project = "em_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_dependency('faraday')
+  s.add_dependency('em-synchrony')
+  s.add_dependency('em-http-request')
+  #s.add_dependency('eventmachine')
+  s.add_runtime_dependency "bigdecimal"
+end

data/lib/hessian2.rb

@@ -0,0 +1,14 @@
+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/version'
+require 'hessian2/writer'
+
+module Hessian2
+  extend Parser, Writer
+end

data/lib/hessian2/class_wrapper.rb

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

data/lib/hessian2/client.rb

@@ -0,0 +1,73 @@
+require 'uri'
+# require 'net/http'
+# require 'net/https'
+require 'hessian2'
+#require 'faraday'
+require 'em-synchrony'
+require "em-synchrony/em-http"
+#require "thread"
+
+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
+      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)
+        # use em_synchrony direct
+        url = "http://#{@host}:#{@port}"
+        result = nil
+        block = lambda {
+                    EM::Synchrony.sync EM::HttpRequest.new(url, :connect_timeout => 5, :inactivity_timeout => 60).post(
+                      :path=>"#{@path}",
+                      :head=>{'Content-Type' => 'application/binary; charset=utf-8'},
+                      :body=>Hessian2.call(method, args)
+                    )
+                }
+        if !EM.reactor_running?
+          EM.synchrony do
+            http = block.call
+            result = Hessian2.parse_rpc(http.response)
+            EM.stop
+          end
+        else
+          http = block.call
+          result = Hessian2.parse_rpc(http.response)
+        end
+        return result
+
+
+       #  #use faraday
+       #  url = "#{@scheme}://#{@host}:#{@port}"
+       #  conn = Faraday.new(:url => url) do |faraday|
+       #    # faraday.request  :url_encoded             # form-encode POST params
+       #    # faraday.response :logger                  # log requests to STDOUT
+       #    faraday.use Faraday::Response::RaiseError  # raise exceptions on 40x, 50x responses
+       #    faraday.use Faraday::Adapter::EMSynchrony
+       #    #faraday.use_ssl = true and conn.verify_mode = OpenSSL::SSL::VERIFY_NONE if @scheme == 'https'
+       #  end
+
+       #  response = conn.post do |req|
+       #    req.url "#{@path}"
+       #    req.headers['Content-Type'] = 'application/binary; charset=utf-8'
+       #    req.body = Hessian2.call(method, args)
+       #    # req.options.timeout = 30         # open/read timeout in seconds
+       #    # req.options.open_timeout = 5      # connection open timeout in seconds
+       #    # req.options.proxy = @proxy
+       # end
+
+       # Hessian2.parse_rpc(response.body)
+    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 x3f, 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