0mq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 773f90d7147a3cbb26b3a5d5133c16e36ec81da5
+  data.tar.gz: 5a241ddd18035b6d933ae28ac328062351d31d48
+SHA512:
+  metadata.gz: 6c986fc018852a26c27241a1f256f20f6066177d9c4590b1da43f35240c33b50522e0cf1e13aa0afe7f9e24027650f3fc424c3d7a8ba7626e8dcd3cbd3c306b3
+  data.tar.gz: d8d5fbc4bd75afa98b4a8101335eda0744a5cd21a73f699c71f3f12650ebd9746bf48b0801bbc71f688d1953f07e59ac8f35c548f88bd793c18ff5d7f9c05e54

data/lib/0mq.rb

@@ -0,0 +1,7 @@
+require 'ffi-rzmq-core'
+
+require_relative '0mq/error_map'
+
+require_relative '0mq/context'
+require_relative '0mq/socket'
+require_relative '0mq/proxy'

data/lib/0mq/context.rb

@@ -0,0 +1,15 @@
+
+module ZMQ
+  
+  class Context
+    attr_reader :ptr
+    
+    def initialize
+      @ptr = LibZMQ.zmq_ctx_new
+    end
+    
+  end
+  
+  DefaultContext = Context.new
+  
+end

data/lib/0mq/error_map.rb

@@ -0,0 +1,20 @@
+
+module ZMQ
+  
+  ErrorMap = Hash.new
+  
+  Errno.constants
+       .map    { |x| Errno.const_get x }
+       .select { |x| x.is_a?(Class) && x < SystemCallError }
+       .each   { |x| ErrorMap[x.const_get(:Errno)] = x }
+  
+  def self.error_check(adjust_backtrace=false)
+    errno = LibZMQ.zmq_errno
+    return true if errno == 25
+    
+    # str = LibZMQ.zmq_strerror(errno).read_string
+    str = ''
+    raise ErrorMap[errno], str, caller[0...-2]
+  end
+  
+end

data/lib/0mq/proxy.rb

@@ -0,0 +1,19 @@
+
+module ZMQ
+  
+  class Proxy
+    
+    def initialize(frontend, backend, capture = nil)
+      @frontend = frontend.nil? ? nil : frontend.ptr
+      @backend  = backend.nil?  ? nil : backend.ptr
+      @capture  = capture.nil?  ? nil : capture.ptr
+    end
+    
+    # Block the current thread with the event loop of the proxy
+    def run
+      LibZMQ.zmq_proxy @frontend, @backend, @capture
+    end
+    
+  end
+  
+end

data/lib/0mq/socket.rb

@@ -0,0 +1,259 @@
+
+module ZMQ
+  
+  class Socket
+    attr_reader :ptr
+    attr_reader :context
+    attr_reader :type
+    
+    def initialize(type, context:ZMQ::DefaultContext)
+      @context = context
+      @type = type
+      @ptr = LibZMQ.zmq_socket @context.ptr, @type
+      
+      @msgptr = FFI::MemoryPointer.new LibZMQ::Message.size, 1, false
+      
+      ObjectSpace.define_finalizer self,
+                                   self.class.finalizer(@socket, Process.pid)
+    end
+    
+    # Close the socket
+    def close
+      if @ptr
+        ObjectSpace.undefine_finalizer self
+        @temp_buffers.clear if @temp_buffers
+        
+        rc = LibZMQ.zmq_close @ptr
+        ZMQ.error_check true if rc==-1
+        
+        @ptr = nil
+      end
+    end
+    
+    # Create a safe finalizer for the socket ptr to close on GC of the object
+    def self.finalizer(ptr, pid)
+      Proc.new { LibZMQ.zmq_close ptr if Process.pid == pid }
+    end
+    
+    # Get the socket type name as a symbol
+    def type_sym
+      ZMQ::SocketTypeNameMap[type].to_sym
+    end
+    
+    # Bind to an endpoint
+    def bind(endpoint)
+      rc = LibZMQ.zmq_bind @ptr, endpoint
+      ZMQ.error_check true if rc==-1
+    end
+    
+    # Connect to an endpoint
+    def connect(endpoint)
+      rc = LibZMQ.zmq_connect @ptr, endpoint
+      ZMQ.error_check true if rc==-1
+    end
+    
+    # Unbind from an endpoint
+    def unbind(endpoint)
+      rc = LibZMQ.zmq_unbind @ptr, endpoint
+      ZMQ.error_check true if rc==-1
+    end
+    
+    # Disconnect to an endpoint
+    def disconnect(endpoint)
+      rc = LibZMQ.zmq_disconnect @ptr, endpoint
+      ZMQ.error_check true if rc==-1
+    end
+    
+    # Send a string to the socket
+    def send_string(string, flags = 0)
+      size = string.respond_to?(:bytesize) ? string.bytesize : string.size
+      @msgbuf = LibC.malloc size
+      @msgbuf.write_string string, size
+      
+      rc = LibZMQ.zmq_msg_init_data @msgptr, @msgbuf, size, LibC::Free, nil
+      ZMQ.error_check true if rc==-1
+      
+      rc = LibZMQ.zmq_sendmsg @ptr, @msgptr, flags
+      ZMQ.error_check true if rc==-1
+      
+      rc = LibZMQ.zmq_msg_close @msgptr
+      ZMQ.error_check true if rc==-1
+    end
+    
+    # Receive a string from the socket
+    def recv_string(flags = 0)
+      rc = LibZMQ.zmq_msg_init @msgptr
+      ZMQ.error_check true if rc==-1
+      
+      rc = LibZMQ.zmq_recvmsg @ptr, @msgptr, flags
+      ZMQ.error_check true if rc==-1
+      
+      str = LibZMQ.zmq_msg_data(@msgptr)
+                  .read_string(LibZMQ.zmq_msg_size(@msgptr))
+      
+      rc = LibZMQ.zmq_msg_close @msgptr
+      ZMQ.error_check true if rc==-1
+      
+      str
+    end
+    
+    # Send a multipart message as an array of strings
+    def send_array(ary)
+      last = ary.last
+      
+      ary[0...-1].each { |str| send_string str, ZMQ::SNDMORE }
+      send_string last
+    end
+    
+    # Receive a multipart message as an array of strings
+    def recv_array
+      [].tap do |ary|
+        loop do
+          ary << recv_string
+          break unless get_opt(ZMQ::RCVMORE)
+        end
+      end
+    end
+    
+    # Set a socket option
+    def set_opt(option, value)
+      type = @@option_types.fetch(option) \
+        { raise ArgumentError, "Unknown option: #{option}" }
+      
+      unless type == :string
+        if type == :bool
+          valptr = FFI::MemoryPointer.new(:int)
+          valptr.write_int(value ? 1 : 0)
+        else
+          valptr = FFI::MemoryPointer.new(type)
+          valptr.send :"write_#{type}", value
+        end
+        value = valptr
+      end
+      
+      rc = LibZMQ.zmq_setsockopt @ptr, option, value, value.size
+      ZMQ.error_check true if rc==-1
+      
+      value
+    end
+    
+    # Get a socket option
+    def get_opt(option)
+      type = @@option_types.fetch(option) \
+        { raise ArgumentError, "Unknown option: #{option}" }
+      
+      value, size = get_opt_pointers type
+      
+      rc = LibZMQ.zmq_getsockopt @ptr, option, value, size
+      ZMQ.error_check true if rc==-1
+      
+      if type == :string
+        value.read_string(size.read_int-1)
+      elsif type == :bool
+        value.read_int == 1
+      else
+        value.send :"read_#{type}"
+      end
+    end
+    
+  private
+    
+    def get_opt_pointers(type)
+      type = :int if type == :bool
+      
+      @temp_buffers ||= { string: [
+          FFI::MemoryPointer.new(255),
+          FFI::MemoryPointer.new(:size_t).write_int(255)
+      ] }
+      @temp_buffers[type] ||= [
+        FFI::MemoryPointer.new(type),
+        FFI::MemoryPointer.new(:size_t).write_int(FFI.type_size(type))
+      ]
+    end
+    
+    @@option_types = {
+    # Get options
+      ZMQ::RCVMORE             => :bool,
+      ZMQ::RCVHWM              => :int,
+      ZMQ::AFFINITY            => :uint64,
+      ZMQ::IDENTITY            => :string,
+      ZMQ::RATE                => :int,
+      ZMQ::RECOVERY_IVL        => :int,
+      ZMQ::SNDBUF              => :int,
+      ZMQ::RCVBUF              => :int,
+      ZMQ::LINGER              => :int,
+      ZMQ::RECONNECT_IVL       => :int,
+      ZMQ::RECONNECT_IVL_MAX   => :int,
+      ZMQ::BACKLOG             => :int,
+      ZMQ::MAXMSGSIZE          => :int64,
+      ZMQ::MULTICAST_HOPS      => :int,
+      ZMQ::RCVTIMEO            => :int,
+      ZMQ::SNDTIMEO            => :int,
+      ZMQ::IPV6                => :bool,
+      ZMQ::IPV4ONLY            => :bool,
+      ZMQ::IMMEDIATE           => :bool,
+      ZMQ::FD                  => :int,
+      ZMQ::EVENTS              => :int,
+      ZMQ::LAST_ENDPOINT       => :string,
+      ZMQ::TCP_KEEPALIVE       => :int,
+      ZMQ::TCP_KEEPALIVE_IDLE  => :int,
+      ZMQ::TCP_KEEPALIVE_CNT   => :int,
+      ZMQ::TCP_KEEPALIVE_INTVL => :int,
+      ZMQ::MECHANISM           => :int,
+      ZMQ::PLAIN_SERVER        => :int,
+      ZMQ::PLAIN_USERNAME      => :string,
+      ZMQ::PLAIN_PASSWORD      => :string,
+      ZMQ::CURVE_PUBLICKEY     => :string,
+      ZMQ::CURVE_SECRETKEY     => :string,
+      ZMQ::CURVE_SERVERKEY     => :string,
+      ZMQ::ZAP_DOMAIN          => :string,
+    }.merge({
+    # Set options
+      ZMQ::SNDHWM              => :int,
+      ZMQ::RCVHWM              => :int,
+      ZMQ::AFFINITY            => :uint64,
+      ZMQ::SUBSCRIBE           => :string,
+      ZMQ::UNSUBSCRIBE         => :string,
+      ZMQ::IDENTITY            => :string,
+      ZMQ::RATE                => :int,
+      ZMQ::RECOVERY_IVL        => :int,
+      ZMQ::SNDBUF              => :int,
+      ZMQ::RCVBUF              => :int,
+      ZMQ::LINGER              => :int,
+      ZMQ::RECONNECT_IVL       => :int,
+      ZMQ::RECONNECT_IVL_MAX   => :int,
+      ZMQ::RECONNECT_IVL       => :int,
+      ZMQ::BACKLOG             => :int,
+      ZMQ::MAXMSGSIZE          => :int64,
+      ZMQ::MULTICAST_HOPS      => :int,
+      ZMQ::RCVTIMEO            => :int,
+      ZMQ::SNDTIMEO            => :int,
+      ZMQ::IPV6                => :bool,
+      ZMQ::IPV4ONLY            => :bool,
+      ZMQ::IMMEDIATE           => :bool,
+      ZMQ::ROUTER_HANDOVER     => :int,
+      ZMQ::ROUTER_MANDATORY    => :int,
+      ZMQ::ROUTER_RAW          => :int,
+      ZMQ::PROBE_ROUTER        => :int,
+      ZMQ::XPUB_VERBOSE        => :int,
+      ZMQ::REQ_CORRELATE       => :int,
+      ZMQ::REQ_RELAXED         => :int,
+      ZMQ::TCP_KEEPALIVE       => :int,
+      ZMQ::TCP_KEEPALIVE_IDLE  => :int,
+      ZMQ::TCP_KEEPALIVE_CNT   => :int,
+      ZMQ::TCP_KEEPALIVE_INTVL => :int,
+      ZMQ::TCP_ACCEPT_FILTER   => :string,
+      ZMQ::PLAIN_SERVER        => :int,
+      ZMQ::PLAIN_USERNAME      => :string,
+      ZMQ::PLAIN_PASSWORD      => :string,
+      ZMQ::CURVE_SERVER        => :int,
+      ZMQ::CURVE_PUBLICKEY     => :string,
+      ZMQ::CURVE_SECRETKEY     => :string,
+      ZMQ::CURVE_SERVERKEY     => :string,
+      ZMQ::ZAP_DOMAIN          => :string,
+      ZMQ::CONFLATE            => :bool,
+    })
+    
+  end
+  
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: 0mq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joe McIlvain
+- Alex McLain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-rzmq-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fivemat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby-like wrapper for ffi-rzmq-core (ZeroMQ)
+email: joe.eli.mac@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/0mq.rb
+- lib/0mq/context.rb
+- lib/0mq/error_map.rb
+- lib/0mq/proxy.rb
+- lib/0mq/socket.rb
+homepage: https://github.com/jemc/0mq/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: 0mq
+test_files: []
+has_rdoc: