bertclient_new 0.4.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011
+
+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,35 @@
+# BERT::Client
+
+BERT::Client is a threadsafe BERT-RPC client with support for persistent 
+connections and SSL. It currently exposes BERT-RPC's cast and call.
+Initially designed to work with *modified* [ernie](https://github.com/mojombo/ernie) server that doesn't close connection after response.
+Tested on ruby 1.9.2
+
+# Dependancies
+
+Requires [BERT](https://github.com/mojombo/bert) gem to be installed.
+
+Requires Jeweler gem to be installed if you want to pack this library into it's own gem.
+
+# Usage
+
+    require 'bertclient'
+    client = BERT::Client.new(:host => 'localhost', :port => 9999)
+    client.call(:calc, :add, 1, 2)
+    #=> 3
+    client.call(:calc, :add, 5, 5)
+    #=> 10
+    client.call(:calc, :sub, 10, 5)
+    #=> 5
+
+You can also use blocks to create ephemeral connections:
+
+    BERT::Client.new(opts) do |client|
+      client.call(:auth, :authenticate, user, password)
+      client.call(:calc, :add, 1, 2)
+    end
+
+# TODO
+
+* Write some tests
+* Package and publish the gem version

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake'
+require 'yaml'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bertclient_new"
+    gem.summary = %Q{BERT::Client is a threadsafe BERT-RPC client with support for persistent connections and SSL}
+    gem.email = "marcin.wtorkowski@gmail.com"
+    gem.homepage = "http://github.com/WTK/bertclient"
+    gem.authors = ["Marcin Wtorkowski"]
+    gem.add_dependency('bert')
+    # gem is a Gem::Specification...
+    # see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+task :default => :version
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bertclient #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/*.rb')
+end
+
+task :console do
+  exec('irb -I lib -r bertclient')
+end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:minor: 4
+:patch: 1
+:build: 

data/bertclient.gemspec

@@ -0,0 +1,43 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bertclient}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcin Wtorkowski"]
+  s.date = %q{2011-04-12}
+  s.email = %q{marcin.wtorkowski@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION.yml",
+    "bertclient.gemspec",
+    "lib/bertclient.rb"
+  ]
+  s.homepage = %q{http://github.com/wtk/bertclient}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.7.2}
+  s.summary = %q{BERT::Client is a threadsafe BERT-RPC client with support for persistent connections and SSL}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<bert>, [">= 0"])
+    else
+      s.add_dependency(%q<bert>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bert>, [">= 0"])
+  end
+end
+

data/lib/bertclient.rb

@@ -0,0 +1,236 @@
+require 'openssl'
+require 'zlib'
+require 'bert'
+
+module BERT
+  class Client
+    class RPCError < StandardError; end
+    class NoSuchModule < RPCError; end
+    class NoSuchFunction < RPCError; end
+    class UserError < RPCError; end
+    class UnknownError < RPCError; end
+    class InvalidResponse < RPCError; end
+    class BadHeader < RPCError; end
+    class BadData < RPCError; end
+
+    GZIP_BERP = t[:info, :encoding, [t[:gzip]]]
+    ACCEPT_ENCODING_BERP = t[:info, :accept_encoding, [t[:gzip]]]
+
+    @socket_pool ||= {}
+
+    def initialize(opts={}, &block)
+      @host = opts[:host] || 'localhost'
+      @port = opts[:port] || 9999
+      @timeout = opts[:timeout] || 15
+
+      @gzip = opts[:gzip] || false
+      @gzip_threshold = opts[:gzip_threshold] || 1024 # bytes
+      @gzip_accept_sent = false
+
+      @ssl = opts[:ssl] || false
+      @verify_ssl = opts.has_key?(:verify_ssl) ? opts[:verify_ssl] : true
+
+      @socket = get_socket_or_create Thread.current
+      
+      execute(&block) if block_given?
+    end
+
+    def call(mod, fun, *args)
+      response = cast_or_call(:call, mod, fun, *args)
+      return response[1] if response[0] == :reply
+
+      handle_error(response)
+    end
+
+    def cast(mod, fun, *args)
+      response = cast_or_call(:cast, mod, fun, *args)
+      return nil if response[0] == :noreply
+
+      handle_error(response)
+    end
+
+    private
+    # Wrapper for both cast and call mechanisms
+    def cast_or_call(cc, mod, fun, *args)
+      req = t[cc, mod.to_sym, fun.to_sym, args]
+      write_berp(req)
+      read_response
+    end
+
+    def read_response
+      gzip_encoded = false
+      response = nil
+
+      loop do
+        response = read_berp
+        break unless response[0] == :info
+
+        # For now we only know how to handle gzip encoding info packets
+        if response == GZIP_BERP
+          gzip_encoded = true
+        else
+          raise NotImplementedError, "Only gzip-encoding related info packets are supported in this version of bertclient"
+        end
+      end
+
+      if gzip_encoded and response[0] == :gzip
+        response = BERT.decode(Zlib::Inflate.inflate(response[1]))
+      end
+
+      response
+    end
+
+    # See bert-rpc.org for error response mechanisms
+    def handle_error(response)
+      unless response[0] == :error
+        raise InvalidResponse, "Expected error response, got: #{response.inspect}"
+      end
+
+      type, code, klass, detail, backtrace = response[1]
+      case type
+      when :server
+        if code == 1
+          raise NoSuchModule
+        elsif code == 2
+          raise NoSuchFunction
+        else
+          raise UnknownError, "Unknown server error: #{response.inspect}"
+        end
+      when :user
+        raise UserError.new("#{klass}: #{detail}\n#{backtrace.join()}")
+      when :protocol
+        if code == 1
+          raise BadHeader
+        elsif code == 2
+          raise BadData
+        else
+          raise UnknownError, "Unknown protocol error: #{response.inspect}"
+        end
+      else
+        raise UnknownError, "Unknown error: #{response.inspect}"
+      end
+    end
+
+    def get_socket_or_create thread
+      sock = Client.get_socket(thread)
+      unless sock
+        sock = Client.set_socket connect(), thread
+      end
+      sock
+    end
+
+    # Creates a socket object which does speedy, non-blocking reads
+    # and can perform reliable read timeouts.
+
+    def connect_old
+      # Create new tcp socket
+      sock = Socket.tcp(@host, @port, Socket::SOCK_STREAM, 0)
+      #
+      sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+      if @ssl
+        sock = OpenSSL::SSL::SSLSocket.new(sock)
+        sock.sync_close = true
+        sock.connect
+        sock.post_connection_check(@host) if @verify_ssl
+      end
+
+      if @timeout
+        secs = Integer(@timeout)
+        usecs = Integer((@timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      end
+
+      sock
+    end
+
+    def connect
+      addr = Socket.getaddrinfo(@host, nil, Socket::AF_INET)
+      sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+      sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+      if @ssl
+        sock = OpenSSL::SSL::SSLSocket.new(sock)
+        sock.sync_close = true
+      end
+
+      if @timeout
+        secs = Integer(@timeout)
+        usecs = Integer((@timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      end
+
+      sock.connect(Socket.pack_sockaddr_in(@port, addr[0][3]))
+      sock.post_connection_check(@host) if @ssl and @verify_ssl
+      sock
+    end
+
+    # Close socket and clean it up from the pool
+    def close
+      @socket.close
+      Client.del_socket Thread.current
+      true
+    end
+
+    # Accepts a block, yields the client, closes socket at the end of the block
+    def execute
+      ret = yield self
+      close
+      ret
+    end
+
+    # Reads a new berp from the socket and returns the decoded object
+    def read_berp
+      length = @socket.read(4).unpack('N').first
+      data = @socket.read(length)
+      BERT.decode(data)
+    end
+
+    # Accepts a Ruby object, converts to a berp and sends through the socket
+    # Optionally sends gzip packet:
+    #
+    # -> {info, encoding, gzip}
+    # -> {gzip, GzippedBertEncodedData}
+    def write_berp(obj)
+      data = BERT.encode(obj)
+      data = negotiate_gzip(data) if @gzip
+      @socket.write(Client.create_berp(data))
+    end
+
+    def negotiate_gzip(data)
+      if not @gzip_accept_sent
+        @gzip_accept_sent = true
+        @socket.write(Client.create_berp(BERT.encode(ACCEPT_ENCODING_BERP)))
+      end
+
+      if data.bytesize > @gzip_threshold
+        @socket.write(Client.create_berp(BERT.encode(GZIP_BERP)))
+        data = BERT.encode(t[:gzip, Zlib::Deflate.deflate(data)])
+      end
+      data
+    end
+
+    class << self
+      # Accepts a string and returns a berp
+      def create_berp(data)
+        [[data.bytesize].pack('N'), data].join
+      end
+      
+      def get_socket thread
+        @socket_pool[thread]
+      end
+
+      def set_socket sock, thread
+        @socket_pool[thread] = sock
+        @socket_pool[thread]
+      end
+
+      def del_socket thread
+        @socket_pool.delete thread
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: bertclient_new
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.4.1
+platform: ruby
+authors: 
+- Marcin Wtorkowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bert
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: marcin.wtorkowski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- VERSION.yml
+- bertclient.gemspec
+- lib/bertclient.rb
+homepage: http://github.com/WTK/bertclient
+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: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: BERT::Client is a threadsafe BERT-RPC client with support for persistent connections and SSL
+test_files: []
+