bundesstrasse 0.0.9

data/lib/bundesstrasse/context.rb

@@ -0,0 +1,33 @@
+
+module Bundesstrasse
+  class Context
+    include Errors
+
+    def initialize(zmq_context)
+      @zmq_context = zmq_context
+    end
+
+    def socket(socket_class, options={})
+      raise ContextError.new("Context terminated") if terminated?
+      zmq_socket = error_check { @zmq_context.socket(socket_class.type) }
+      socket = socket_class.new(zmq_socket, options)
+    rescue ZMQError => e
+      ContextError.raise_error(e)
+    end
+
+    def terminate!
+      @zmq_context.terminate
+      true
+    end
+
+    def terminated?
+      @zmq_context.context.nil?
+    end
+
+    def self.create(options={})
+      new ZMQ::Context.create(options[:io_threads] || 1)
+    end
+  end
+
+  ContextError = Class.new(ZMQError)
+end

data/lib/bundesstrasse/device.rb

@@ -0,0 +1,37 @@
+
+module Bundesstrasse
+  class Device
+    include Errors
+    
+    attr_reader :frontend, :backend
+    def initialize(type, frontend, backend)
+      @type = type
+      @frontend = frontend
+      @backend = backend
+    end
+    
+    def start
+      error_check do
+        ZMQ::LibZMQ.zmq_device(@type, @frontend.pointer, @backend.pointer)
+      end
+    end
+
+    private
+
+    def close!
+      @frontend.close!
+      @backend.close!
+    end
+
+    def error_check(&block)
+      super
+    rescue ZMQError => e
+      case e.error_code
+      when ZMQ::ETERM then close!
+      else DeviceError.raise_error(e)
+      end
+    end
+  end
+
+  DeviceError = Class.new(ZMQError)
+end

data/lib/bundesstrasse/devices.rb

@@ -0,0 +1,43 @@
+module Bundesstrasse
+  class QueueDevice < Device
+    attr_reader :context
+    def initialize(context, frontend, backend)
+      super(ZMQ::QUEUE, frontend, backend)
+      @context = context
+    end
+    
+    def create_endpoint!(options={})
+      @context.socket(RepSocket, options)
+    end
+
+    def self.create(context)
+      frontend = context.socket(RouterSocket)
+      backend = context.socket(DealerSocket)
+      new(context, frontend, backend)
+    end
+  end
+
+  class ForwarderDevice < Device
+    def initialize(frontend, backend)
+      super(ZMQ::FORWARDER, frontend, backend)
+    end
+    
+    def self.create(context)
+      frontend = context.socket(SubSocket)
+      backend = context.socket(PubSocket)
+      new(frontend, backend)
+    end
+  end
+
+  class StreamerDevice < Device
+    def initialize(frontend, backend)
+      super(ZMQ::STREAMER, frontend, backend)
+    end
+    
+    def self.create(context)
+      frontend = context.socket(PullSocket)
+      backend = context.socket(PushSocket)
+      new(frontend, backend)
+    end
+  end
+end

data/lib/bundesstrasse/errors.rb

@@ -0,0 +1,31 @@
+module Bundesstrasse
+  class ZMQError < StandardError
+    attr_reader :error_code
+    def initialize(message, error_code=-1)
+      @error_code = error_code
+      super(message)
+    end
+
+    def self.raise_error(e)
+      raise new(e.message, e.error_code)
+    end
+  end
+
+  module Errors
+    def errno
+      ZMQ::Util.errno
+    end
+
+    def error_string
+      ZMQ::Util.error_string
+    end
+
+    def error_check(&block)
+      if (res = block.call).is_a? Fixnum
+        res = res >= 0
+      end
+      raise ZMQError.new(error_string, errno) unless res
+      res
+    end
+  end
+end

data/lib/bundesstrasse/socket.rb

@@ -0,0 +1,98 @@
+module Bundesstrasse
+  class Socket
+    include Errors
+
+    def initialize(socket, options={})
+      @socket = socket
+      setup!(options)
+    end
+
+    def bind(address)
+      @connected = error_check { @socket.bind(address) }
+    end
+
+    def connect(address)
+      @connected = error_check { @socket.connect(address) }
+    end
+
+    def close!
+      !(@connected = !error_check { @socket.close })
+    end
+
+    def read(buffer='')
+      connected_error_check { @socket.recv_string buffer }
+      buffer
+    end
+
+    def write(message)
+      connected_error_check { @socket.send_string(message) }
+    end
+
+    def read_nonblocking(buffer='')
+      connected_error_check { @socket.recv_string(buffer, ZMQ::NonBlocking) }
+      buffer
+    end
+
+    def write_nonblocking(message)
+      connected_error_check { @socket.send_string(message, ZMQ::NonBlocking) }
+    end
+
+    def read_multipart
+      messages = []
+      connected_error_check { @socket.recv_strings(messages) }
+      messages
+    end
+
+    def write_multipart(*parts)
+      connected_error_check { @socket.send_strings(parts) }
+    end
+
+    def more_parts?
+      @socket.more_parts?
+    end
+
+    def pointer
+      @socket.socket
+    end
+    alias_method :socket, :pointer
+
+    def connected?
+      @connected
+    end
+
+    def self.type
+      raise NotImplementedError, 'Subclasses must override Socket::type'
+    end
+
+    private
+
+    def connected_error_check(&block)
+      raise SocketError, 'Not connected' unless connected?
+      error_check(&block)
+    end
+
+    def error_check(&block)
+      super
+    rescue ZMQError => e
+      case e.error_code
+      when ZMQ::ETERM then close! && TermError.raise_error(e)
+      when ZMQ::EAGAIN then AgainError.raise_error(e)
+      else SocketError.raise_error(e)
+      end
+    end
+
+    def setup!(options)
+      options.each do |option, value|
+        begin
+          error_check { @socket.setsockopt ZMQ.const_get(option.upcase), value }
+        rescue NameError => e
+          raise ArgumentError, "Unknown socket option '#{option}'", e.backtrace
+        end
+      end
+    end
+  end
+
+  SocketError = Class.new(ZMQError)
+  TermError = Class.new(ZMQError)
+  AgainError = Class.new(ZMQError)
+end

data/lib/bundesstrasse/sockets.rb

@@ -0,0 +1,70 @@
+
+module Bundesstrasse
+  class ReqSocket < Socket
+    def self.type
+      ZMQ::REQ
+    end
+  end
+
+  class RepSocket < Socket
+    def self.type
+      ZMQ::REP
+    end
+  end
+
+  class DealerSocket < Socket
+    def self.type
+      ZMQ::DEALER
+    end
+  end
+
+  class RouterSocket < Socket
+    def self.type
+      ZMQ::ROUTER
+    end
+  end
+
+  class PushSocket < Socket
+    def self.type
+      ZMQ::PUSH
+    end
+  end
+
+  class PullSocket < Socket
+    def self.type
+      ZMQ::PULL
+    end
+  end
+
+  class PubSocket < Socket
+    def self.type
+      ZMQ::PUB
+    end
+  end
+
+  class SubSocket < Socket
+    def self.type
+      ZMQ::SUB
+    end
+    
+    def subscribe(topic)
+      error_check { @socket.setsockopt(ZMQ::SUBSCRIBE, topic) }
+    end
+    
+    def unsubscribe(topic)
+      error_check { @socket.setsockopt(ZMQ::UNSUBSCRIBE, topic) }
+    end
+  end
+
+  class XPubSocket < Socket
+    def self.type
+      ZMQ::XPUB
+    end
+  end
+
+  class XSubSocket < SubSocket
+    def self.type
+      ZMQ::XSUB
+    end
+  end
+end

data/lib/bundesstrasse/version.rb

@@ -0,0 +1,3 @@
+module Bundesstrasse
+  VERSION = '0.0.9'.freeze
+end

data/lib/bundesstrasse.rb

@@ -0,0 +1,8 @@
+require 'ffi-rzmq'
+
+require 'bundesstrasse/errors'
+require 'bundesstrasse/context'
+require 'bundesstrasse/socket'
+require 'bundesstrasse/sockets'
+require 'bundesstrasse/device'
+require 'bundesstrasse/devices'

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: bundesstrasse
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+  prerelease:
+platform: ruby
+authors:
+- Joel Segerlind
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-rzmq
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+description: Basic ZeroMQ wrapper for JRuby
+email:
+- joel@kogito.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bundesstrasse.rb
+- lib/bundesstrasse/context.rb
+- lib/bundesstrasse/device.rb
+- lib/bundesstrasse/devices.rb
+- lib/bundesstrasse/errors.rb
+- lib/bundesstrasse/socket.rb
+- lib/bundesstrasse/sockets.rb
+- lib/bundesstrasse/version.rb
+homepage: https://github.com/jowl/bundesstrasse
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: A thin wrapper around ffi-rzmq, providing basic functionality
+test_files: []