czmq 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7eabd4190bbf945fbd382a438ef2db82175b33d1
+  data.tar.gz: 005591101a505c8ab35675056b9e9250d4ed01df
+SHA512:
+  metadata.gz: cb1d5f8ce7967c628969678b8eaa1cfce4f1c174994a24ccb3ff9607f874dfd69ca9f140dca4510829da5a6b18ecf330211e4521a0fe077b2d6983bf40bd044e
+  data.tar.gz: a3120e91b841fe3abc8fdb190b06cc60d488f0b59814a7ca2410e6b36ae768ff654af5d770a892f2c57cc71217a646e41ef20b8bd3abd209d231d154993e12a6

data/.gitignore

@@ -0,0 +1,22 @@
+*~
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-version
+.ruby-gemset
+coverage
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-czmq.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mauro Tortonesi
+
+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,66 @@
+# ruby-czmq
+
+ruby-czmq is my attempt at building a Ruby bindings gem for the
+[CZMQ](http://czmq.zeromq.org/) library.
+
+ruby-czmq realizes a convenient and relatively elegant API on top of the
+FFI-based [ruby-czmq-ffi](https://github.com/mtortonesi/ruby-czmq-ffi) gem,
+which provides low-level bindings to CZMQ and works on all the main Ruby VMs:
+YARV/MRI, JRuby, and Rubinius.
+
+
+## Motivation
+
+One could wonder whether there was actually the need for a third gem (in
+addition to [ffi-rzmq](https://github.com/chuckremes/ffi-rzmq) and the more
+outdated and YARV/MRI-specific [rbzmq](https://github.com/zeromq/rbzmq))
+providing Ruby bindings for [ZeroMQ](http://zeromq.org/).
+
+The fact is that both ffi-rzmq and rzmq are bindings for the ZeroMQ library.
+ZeroMQ is an awesome library, but it provides a rather low-level API designed
+for C/C++ and relatively difficult to make available to Ruby applications
+through a convenient and elegant interface. Instead, ruby-czmq provides
+bindings to [CZMQ](http://czmq.zeromq.org/), a library that was specifically
+designed to provide a higher-level API to the ZeroMQ functions and that is
+significantly more Ruby-friendly than ZeroMQ. In addition, CZMQ provides
+functions, such as service discovery and cryptography, that are not present in
+ZeroMQ.
+
+By interfacing with CZMQ, instead of ZeroMQ, ruby-czmq can provide many of the
+functions of ffi-rzmq and rbzmq with significantly less code.
+
+
+## Installation
+
+### Stable version
+
+You can get the stable version of ruby-czmq by installing the czmq gem from
+RubyGems:
+
+    gem install czmq
+
+### Development version
+
+If you want to try the development version of ruby-czmq, instead, just place
+these lines:
+
+```ruby
+gem 'czmq-ffi', git: 'https://github.com/mtortonesi/ruby-czmq-ffi.git'
+gem 'czmq', git: 'https://github.com/mtortonesi/ruby-czmq.git'
+```
+
+in your Gemfile and run:
+
+    bundle install
+
+
+## Examples
+
+You can find some simple examples that demonstrate how to use the ruby-czmq api
+in the [examples directory](https://github.com/mtortonesi/ruby-czmq/tree/master/examples)
+of this project.
+
+
+## License
+
+MIT

data/Rakefile

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

data/czmq.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'czmq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'czmq'
+  spec.version       = CZMQ::VERSION
+  spec.authors       = ['Mauro Tortonesi']
+  spec.email         = ['mauro.tortonesi@unife.it']
+  spec.description   = %q{Ruby bindings for CZMQ}
+  spec.summary       = %q{Ruby gem that provides bindings for the CZMQ library.
+    This is a pure Ruby gem that interfaces with CZMQ using FFI, so it
+    should work under MRI, JRuby, and Rubinius.}
+  spec.homepage      = 'https://github.com/mtortonesi/ruby-czmq'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'czmq-ffi'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/examples/simple_dealerrep_example/dealer_node.rb

@@ -0,0 +1,26 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::DEALER)
+  zsocket.connect('tcp://localhost:7000')
+  zsocket.connect('tcp://localhost:8000')
+  zsocket.connect('tcp://localhost:9000')
+
+  3.times do
+    # in order to talk with REP sockets, we need to prepend each request with
+    # a null string frame
+    zsocket.send_string('', :more)
+    zsocket.send_string('request')
+
+    # rep will be an array of strings, with rep[0] containing an empty string
+    # and rep[1] containing the actual reply
+    rep = zsocket.receive_strings
+    puts rep[1]
+  end
+
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_dealerrep_example/rep_node_7000.rb

@@ -0,0 +1,15 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::REP)
+  zsocket.bind('tcp://*:7000')
+
+  puts zsocket.receive_string
+  zsocket.send_string('reply')
+
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_dealerrep_example/rep_node_8000.rb

@@ -0,0 +1,15 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::REP)
+  zsocket.bind('tcp://*:8000')
+
+  puts zsocket.receive_string
+  zsocket.send_string('reply')
+
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_dealerrep_example/rep_node_9000.rb

@@ -0,0 +1,15 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::REP)
+  zsocket.bind('tcp://*:9000')
+
+  puts zsocket.receive_string
+  zsocket.send_string('reply')
+
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_reqrep_example/client.rb

@@ -0,0 +1,13 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::REQ)
+  zsocket.connect('tcp://localhost:8000')
+  zsocket.send_string('request')
+  puts zsocket.receive_string
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_reqrep_example/server.rb

@@ -0,0 +1,14 @@
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  puts CZMQ::REP
+  zsocket = ctx.create_zsocket(CZMQ::REP)
+  puts zsocket.bind('tcp://*:8000')
+  puts zsocket.receive_string
+  zsocket.send_string('response')
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_zbeacon_example/client.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  zsocket = ctx.create_zsocket(CZMQ::REQ)
+  zsocket.connect('tcp://localhost:8000')
+  zsocket.send_string('request')
+  puts zsocket.receive_string
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/simple_zbeacon_example/server.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'czmq'
+
+ctx = CZMQ::Context.new
+if ctx
+  puts CZMQ::REP
+  zbeacon = ctx.create_zbeacon(9999) # use port 9999
+  zsocket = ctx.create_zsocket(CZMQ::REP)
+  puts zsocket.bind('tcp://*:8000')
+  puts zsocket.receive_string
+  zsocket.send_string('response')
+  zsocket.close
+  ctx.close
+else
+  STDERR.puts 'Context allocation failed.'
+end

data/examples/zloop_reqrep_example/client.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'czmq'
+
+begin
+  ctx = CZMQ::Context.new
+  zsocket = ctx.create_zsocket(CZMQ::REQ)
+  zsocket.connect('tcp://localhost:8000')
+  puts 'sending string'
+  zsocket.send_string('request')
+  puts zsocket.receive_string
+  zsocket.close
+  ctx.close
+rescue => e
+  STDERR.puts e.backtrace
+end

data/examples/zloop_reqrep_example/server.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'czmq'
+
+ctx = CZMQ::Context.new
+abort 'Context allocation failed.' unless ctx
+
+zsocket = ctx.create_zsocket(CZMQ::REP)
+
+begin
+  zsocket.bind('tcp://*:8000')
+  zloop = CZMQ::ZLoop.new
+  pi = zsocket.to_pollitem
+  zloop.poller(pi) do |zlp,socket|
+    str = socket.receive_string
+    puts "Received on REQ/REP ZSocket: #{str}"; STDOUT.flush
+    socket.send_string(str.reverse)
+  end
+  zloop.start
+rescue => e
+  STDERR.puts e.inspect
+  STDERR.puts e.backtrace
+end
+
+zsocket.close
+ctx.close

data/examples/zloop_timer_example/zloop_timer.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'czmq'
+
+zloop = CZMQ::ZLoop.new
+zloop.add_timer(2_000, 2) do |*args|
+  puts "#{Time.now} called block inside first callback"
+  puts "args = #{args.inspect}"
+end
+zloop.add_timer(10_000, 1) do |*args|
+  puts "#{Time.now} called block inside second callback"
+  puts "args = #{args.inspect}"
+end
+zloop.start

data/lib/czmq.rb

@@ -0,0 +1,9 @@
+require 'czmq-ffi'
+
+require 'czmq/context'
+require 'czmq/version'
+require 'czmq/zbeacon'
+require 'czmq/zframe'
+require 'czmq/zmsg'
+require 'czmq/zloop'
+require 'czmq/zsocket'

data/lib/czmq/context.rb

@@ -0,0 +1,68 @@
+require 'ffi'
+
+module CZMQ
+  class Context
+
+    def initialize(opts = {})
+      # TODO: check this code
+      _DEFAULT_OPTS = { io_threads: 1, linger: 0 }
+      opts = _DEFAULT_OPTS.merge(opts)
+
+      @zctx = LibCZMQ.zctx_new
+      # TODO: check that this is not null
+
+      # Setup multiple I/O threads if requested
+      if opts[:io_threads].is_a? Numeric and opts[:io_threads] > 1
+        LibCZMQ.zctx_set_iothreads(@zctx, opts[:io_threads])
+      end
+
+      setup_finalizer
+    end
+
+    def close
+      if @zctx
+        # Since we explicitly close the zctx, we have to remove the finalizer.
+        remove_finalizer
+        LibCZMQ.zctx_destroy(@zctx)
+        @zctx = nil
+      end
+    end
+
+    def create_zsocket(type, opts={})
+      ZSocket.new(@zctx, type, opts)
+    end
+
+    def create_zbeacon(port, opts={})
+      ZBeacon.new(@zctx, port, opts)
+    end
+
+    # TODO: consider whether to provide the set_iothreads and set_linger methods as well.
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zctx is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zctx(@zctx))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zctx(zctx)
+        Proc.new do
+          LibCZMQ.zctx_destroy(zctx)
+          zctx = nil # Just in case
+        end
+      end
+  end
+end

data/lib/czmq/version.rb

@@ -0,0 +1,3 @@
+module CZMQ
+  VERSION = "0.0.1"
+end

data/lib/czmq/zbeacon.rb

@@ -0,0 +1,112 @@
+module CZMQ
+  class ZBeacon
+    def initialize(ctx, port, opts={})
+      @ctx = ctx
+      @zbeacon = LibCZMQ.zbeacon_new(port)
+
+      # zbeacon_new returns NULL in case of failure
+      raise 'Could not create ZBeacon' if @zbeacon.null?
+
+      # Setup no_echo option if requested
+      if opts[:no_echo]
+        LibCZMQ.zbeacon_no_echo(@zbeacon)
+      end
+
+      # Setup the finalizer to free the memory allocated by the CZMQ library
+      setup_finalizer
+    end
+
+    def close
+      if @zbeacon
+        # Since we explicitly close the ZBeacon, we have to remove the finalizer.
+        remove_finalizer
+
+        # Destroy the ZBeacon
+        LibCZMQ.zbeacon_destroy(@zbeacon)
+
+        # Unset @zbeacon
+        @zbeacon = nil
+      end
+    end
+
+    def hostname
+      raise "Can't get the hostname of a closed ZBeacon!" unless @zbeacon
+      LibCZMQ.zbeacon_hostname(@zbeacon)
+    end
+
+    def set_interval(interval)
+      raise "Can't set the advertisement interval of a closed ZBeacon!" unless @zbeacon
+      LibCZMQ.zbeacon_set_interval(@zbeacon, interval)
+    end
+
+    def publish(data)
+      raise "Can't publish advertisements on a closed ZBeacon!" unless @zbeacon
+
+      # Transform data into a bytes array
+      bytes = to_bytearray(data)
+
+      LibCZMQ.zbeacon_publish(@zbeacon, bytes)
+    end
+
+    def silence
+      raise "Can't silence an uninitialized ZBeacon!" unless @zbeacon
+      LibCZMQ.zbeacon_silence(@zbeacon)
+    end
+
+    def subscribe(match=nil)
+      raise "Can't subscribe to an uninitialized ZBeacon!" unless @zbeacon
+      LibCZMQ.zbeacon_subscribe(@zbeacon, match)
+    end
+
+    def unsubscribe
+      raise "Can't unsubscribe from an uninitialized ZBeacon!" unless @zbeacon
+      LibCZMQ.zbeacon_unsubscribe(@zbeacon)
+    end
+
+    def socket
+      raise "Can't get socket of an uninitialized ZBeacon!" unless @zbeacon
+      ZSocket.new(@ctx, LibCZMQ.zbeacon_socket(@zbeacon))
+    end
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zbeacon is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zbeacon(@zbeacon))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zbeacon(zbeacon)
+        Proc.new do
+          LibCZMQ.zbeacon_destroy(zbeacon)
+          zbeacon = nil # Just in case
+        end
+      end
+
+      def to_bytearray(data)
+        bytes = nil
+        if data.is_a? String
+          # String to byte array conversion using the default UTF-8 encoding
+          # bytes = data.bytes.to_a
+          bytes = data.encode("UTF-8").bytes.to_a
+        elsif data.respond_to? :to_a and !data.is_a? Array
+          bytes = data
+        else
+          raise "Don't know how to deal with data" unless data.is_a? Array
+        end
+        bytes
+      end
+  end
+end

data/lib/czmq/zframe.rb

@@ -0,0 +1,71 @@
+require 'ffi'
+
+module CZMQ
+  class ZFrame
+    def initialize(obj=nil)
+      if obj.is_a? FFI::Pointer
+        @zframe = obj
+      else
+        @zframe = LibCZMQ.zframe_new(obj)
+      end
+
+      setup_finalizer
+    end
+
+    # Need to provide a copy constructor that implements deep copy
+    def initialize_copy(orig)
+      super
+      unless @zframe.nil?
+        @zframe = LibCZMQ.zframe_dup(@zframe)
+      end
+    end
+
+    def destroy
+      if @zframe
+        # Since we explicitly close the zframe, we have to remove the finalizer.
+        remove_finalizer
+        LibCZMQ.zframe_destroy(@zframe)
+        raise 'Error!' unless @zframe.nil?
+      end
+    end
+
+    def __extract__
+      raise 'Trying to extract internal @zframe pointer from an unitialized ZFrame!' if @zframe.nil?
+
+      # Since we explicitly hand over the @zframe pointer, we have to remove the finalizer.
+      remove_finalizer
+
+      # Return content of @zframe pointer and reset it to nil
+      zframe = @zframe
+      @zframe = nil
+      zframe
+    end
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zframe is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zframe(@zframe))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zframe(zframe)
+        Proc.new do
+          LibCZMQ.zframe_destroy(zframe)
+          zframe = nil # Just in case
+        end
+      end
+  end
+end

data/lib/czmq/zloop.rb

@@ -0,0 +1,89 @@
+module CZMQ
+  class ZLoop
+    def initialize(zloop=nil)
+      @zloop = zloop || LibCZMQ.zloop_new
+
+      # LibCZMQ.zloop_set_verbose(@zloop, true)
+
+      unless zloop
+        setup_finalizer
+      end
+    end
+
+    def destroy
+      if @zloop
+        # Since we explicitly close the zloop, we have to remove the finalizer.
+        remove_finalizer
+        rc = LibCZMQ.zloop_destroy(@zloop)
+        raise 'Error!' unless @zloop.nil?
+        rc
+      end
+    end
+
+    def start
+      raise 'Trying to start an unitialized ZLoop!' if @zloop.nil?
+      LibCZMQ.zloop_start(@zloop)
+    end
+
+    def poller(poll_item, func=nil, &block)
+      raise 'Trying to add a poller to an unitialized ZLoop!' if @zloop.nil?
+      raise ArgumentError, 'You need to provide a block or a proc/lambda!' unless block_given? or func.responds_to :call
+
+      the_proc = block_given? ? block.to_proc : func
+
+      # need to preserve this callback from the garbage collector
+      @callback = LibCZMQ.create_zloop_callback(
+        lambda do |zloopbuf, zpollitembuf, arg|
+          zpollitem = LibCZMQ::ZPollItem.new(zpollitembuf)
+          zlp = ZLoop.new(zloopbuf)
+          zsk = ZSocket.new(nil, zpollitem[:socket])
+          the_proc.call(zlp, zsk)
+        end
+      )
+
+      LibCZMQ.zloop_poller(@zloop, poll_item, @callback, nil)
+    end
+
+    alias_method :add_poller, :poller
+
+    def poller_end(poll_item)
+      LibCZMQ.zloop_poller_end(@zloop, poll_item)
+      @callback = nil
+    end
+
+    alias_method :remove_poller, :poller_end
+
+    def add_timer(delay, times, &block)
+      if block
+        LibCZMQ.zloop_timer(@zloop, delay, times, block.to_proc, nil)
+      end
+    end
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zloop is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zloop(@zloop))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zloop(zloop)
+        Proc.new do
+          LibCZMQ.zloop_destroy(zloop)
+          zloop = nil # Just in case
+        end
+      end
+  end
+end

data/lib/czmq/zmsg.rb

@@ -0,0 +1,112 @@
+module CZMQ
+  class ZMessage
+    def initialize(zmsg=nil)
+      @zmsg = zmsg || LibCZMQ.zmsg_new
+
+      setup_finalizer
+    end
+
+    # Need to provide a copy constructor that implements deep copy
+    def initialize_copy(orig)
+      super
+      unless @zmsg.nil?
+        @zmsg = LibCZMQ.zmsg_dup(@zmsg)
+      end
+    end
+
+    def destroy
+      if @zmsg
+        # Since we explicitly close the zmsg, we have to remove the finalizer.
+        remove_finalizer
+        LibCZMQ.zmsg_destroy(@zmsg)
+        raise 'Error!' unless @zmsg.nil?
+      end
+    end
+
+    def __send_over(zsocket)
+      raise 'Trying to transmit an unitialized ZMessage!' if @zmsg.nil?
+      # Since by sending it over a zsocket we explicitly close the zmsg, we
+      # have to remove the finalizer.
+      remove_finalizer
+      rc = LibCZMQ.zmsg_send(@zmsg, zsocket)
+      raise 'Error!' unless @zmsg.nil?
+      rc
+    end
+
+    def size
+      LibCZMQ.zmsg_size(@zmsg)
+    end
+
+    def content_size
+      LibCZMQ.zmsg_content_size(@zmsg)
+    end
+
+    def pop(type=:zframe)
+      raise 'Trying to pop from an unitialized ZMessage!' if @zmsg.nil?
+
+      case type
+      when :zframe
+        ZFrame.new(LibCZMQ.zmsg_pop(@zmsg))
+      when :string
+        LibCZMQ.zmsg_popstr(@zmsg)
+      end
+    end
+
+    # Push new frame in front of message
+    def push(obj)
+      raise 'Trying to push in front of an unitialized ZMessage!' if @zmsg.nil?
+
+      if obj.is_a? String
+        LibCZMQ.zmsg_pushstr(@zmsg, obj)
+      elsif obj.is_a? Array
+        LibCZMQ.zmsg_pushmem(@zmsg, obj)
+      elsif obj.is_a? ZFrame
+        LibCZMQ.zmsg_push(@zmsg, obj.__extract__)
+      else
+        raise ArgumentError, 'Unknown object type!'
+      end
+    end
+
+    # Append new frame at the end of message
+    def append(obj)
+      raise 'Trying to append to an unitialized ZMessage!' if @zmsg.nil?
+
+      if obj.is_a? String
+        LibCZMQ.zmsg_addstr(@zmsg, obj)
+      elsif obj.is_a? ZFrame
+        LibCZMQ.zmsg_append(@zmsg, obj.__extract__)
+      else
+        raise ArgumentError, 'Unknown object type!'
+      end
+    end
+
+    alias_method :<<, :append
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zmsg is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zmsg(@zmsg))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zmsg(zmsg)
+        Proc.new do
+          LibCZMQ.zmsg_destroy(zmsg)
+          zmsg = nil # Just in case
+        end
+      end
+  end
+end

data/lib/czmq/zpoller.rb

@@ -0,0 +1,85 @@
+module CZMQ
+  class ZPoller
+
+    def initialize(zctx, *zobjs)
+      raise ArgumentError, 'Must provide at least one ZSocket!' if zobjs.empty?
+
+      # # Need to save context for ZSocket operations
+      # @zctx = zctx
+      @zsockets = zobjs
+
+      # We need to setup the ZPoller from zsocket pointers, not ZSocket objects
+      zsocks = zobjs.map{|zo| zo.__get_zsocket_pointer__ }
+
+      # Create zpoller by calling zpoller_new
+      first_arg = zsocks.shift
+      if zsocks.empty?
+        # We just need to pass a single argument
+        @zpoller = LibCZMQ.zpoller_new(first_arg)
+      else
+        # We also need to pass additional arguments, using the horrible varargs interface
+        other_args = ([ :pointer ] * zsocks.size).zip(zsocks).flatten
+        @zpoller = LibCZMQ.zpoller_new(first_arg, *other_args)
+      end
+
+      setup_finalizer
+    end
+
+
+    def destroy
+      if @zpoller
+        # Since we explicitly close the zpoller, we have to remove the finalizer.
+        remove_finalizer
+        LibCZMQ.zpoller_destroy(@zpoller)
+        raise 'Error!' unless @zpoller.nil?
+      end
+    end
+
+
+    def wait(timeout)
+      raise "Can't wait on an uninitialized ZPoller!" unless @zpoller
+      # TODO: should we return a newly created ZSocket or an existing one?
+      zsockptr = LibCZMQ.zpoller_wait(@zpoller, timeout)
+      yield zsockets.select{|zsock| zsock.__get_zsocket_pointer__ == zsockptr }
+    end
+
+
+    def expired?
+      raise "Can't check if an uninitialized ZPoller is expired!" unless @zpoller
+      LibCZMQ.zpoller_expired(@zpoller)
+    end
+
+
+    def terminated?
+      raise "Can't check if an uninitialized ZPoller is terminated!" unless @zpoller
+      LibCZMQ.zpoller_terminated(@zpoller)
+    end
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zpoller is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zpoller(@zpoller))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zpoller(zpoller)
+        Proc.new do
+          LibCZMQ.zpoller_destroy(zpoller)
+          zpoller = nil # Just in case
+        end
+      end
+  end
+end

data/lib/czmq/zsocket.rb

@@ -0,0 +1,151 @@
+require 'czmq-ffi'
+
+
+module CZMQ
+  class ZSocket
+
+    def initialize(zctx, obj, opts = {})
+      @zctx = zctx
+
+      if obj.is_a? FFI::Pointer
+        @zsocket = obj
+      else
+        @zsocket = LibCZMQ.zsocket_new(zctx, obj)
+        # TODO: Maybe check that zsocket is not null?
+      end
+
+      setup_finalizer
+    end
+
+    def close
+      if @zsocket
+        # Since we explicitly close the zsocket, we have to remove the finalizer.
+        remove_finalizer
+        LibCZMQ.zsocket_destroy(@zctx, @zsocket)
+        @zsocket = nil
+      end
+    end
+
+    def bind(address, opts={})
+      raise "Can't bind a closed ZSocket!" unless @zsocket
+      # TODO: pass opts to zsocket_bind using varargs
+      LibCZMQ.zsocket_bind(@zsocket, address)
+    end
+
+    def unbind(address, opts={})
+      raise "Can't unbind a closed ZSocket!" unless @zsocket
+      # TODO: pass opts to zsocket_unbind using varargs
+      LibCZMQ.zsocket_unbind(@zsocket, address)
+    end
+
+    def connect(address, opts={})
+      raise "Can't connect a closed ZSocket!" unless @zsocket
+      # TODO: pass opts to zsocket_connect using varargs
+      LibCZMQ.zsocket_connect(@zsocket, address)
+    end
+
+    def disconnect(address, opts={})
+      raise "Can't disconnect a closed ZSocket!" unless @zsocket
+      # TODO: pass opts to zsocket_disconnect using varargs
+      LibCZMQ.zsocket_disconnect(@zsocket, address)
+    end
+
+    def poll(msecs)
+      raise "Can't poll a closed ZSocket!" unless @zsocket
+      LibCZMQ.zsocket_poll(@zsocket, msecs)
+    end
+
+    def type
+      raise "Can't read type of a closed ZSocket!" unless @zsocket
+      LibCZMQ.zsocket_type_str(@zsocket)
+    end
+
+    def receive_string(*opts)
+      if opts.include? :no_wait
+        # NOTE: There is no need to raise exception if zstr_recv_nowait returns
+        # NULL. That's a perfectly fine result, meaning that we don't have any
+        # strings in the CZMQ RX buffers.
+        LibCZMQ.zstr_recv_nowait(@zsocket)
+      else
+        str = LibCZMQ.zstr_recv(@zsocket)
+        # TODO: Do we really need to raise an exception if the string is nil?
+        raise "Can't read string from ZSocket" if str.nil?
+        str
+      end
+    end
+
+    def receive_strings
+      strings = []
+      zmsg = self.receive_message
+      str = zmsg.pop(:string)
+      while str
+        strings << str
+        str = zmsg.pop(:string)
+      end
+      strings
+    end
+
+    def send_string(str, *opts)
+      if opts.include? :more
+        LibCZMQ.zstr_sendm(@zsocket, str)
+        # TODO: check the code returned by zstr_sendm?
+      elsif opts.include? :multipart
+        # TODO: call zstr_sendx
+      else
+        LibCZMQ.zstr_send(@zsocket, str)
+        # TODO: check the code returned by zstr_send?
+      end
+    end
+
+    def receive_message
+      ZMessage.new(LibCZMQ.zmsg_recv(@zsocket))
+    end
+
+    def send_message(zmsg)
+      zmsg.__send_over(@zsocket)
+    end
+
+    # TODO: implement this
+    # def sendmem
+    #   raise "Can't sendmem to a closed ZSocket!" unless @zsocket
+    # end
+
+    def __get_zsocket_pointer__
+      @zsocket
+    end
+
+    alias_method :to_ptr, :__get_zsocket_pointer__
+
+    def to_pollitem(polling_type=CZMQ::POLLIN)
+      raise "Can't convert an uninitialized/closed ZSocket to a pollitem!" unless @zsocket
+      # TODO: check what to do in case we have a pollitem with a different poll type
+      LibCZMQ.create_pollitem(socket: @zsocket, events: polling_type)
+    end
+
+
+    private
+
+      # After object destruction, make sure that the corresponding zsocket is
+      # destroyed as well.
+      #
+      # NOTE: We don't care about ensuring, as ffi-rmzq does, that the resource
+      # deallocation request comes from the process that allocated it in the first place.
+      # In fact, the CZMQ documentation at http://zeromq.org/area:faq explicitly states
+      # "It is not safe to share a context or sockets between a parent and its child."
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.close_zsocket(@zctx, @zsocket))
+      end
+
+      def remove_finalizer
+        ObjectSpace.undefine_finalizer self
+      end
+
+      # Need to make this a class method, or the deallocation won't take place. See:
+      # http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def self.close_zsocket(zctx, zsocket)
+        Proc.new do
+          LibCZMQ.zsocket_destroy(zctx, zsocket)
+        end
+      end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: czmq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mauro Tortonesi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: czmq-ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: Ruby bindings for CZMQ
+email:
+- mauro.tortonesi@unife.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- czmq.gemspec
+- examples/simple_dealerrep_example/dealer_node.rb
+- examples/simple_dealerrep_example/rep_node_7000.rb
+- examples/simple_dealerrep_example/rep_node_8000.rb
+- examples/simple_dealerrep_example/rep_node_9000.rb
+- examples/simple_reqrep_example/client.rb
+- examples/simple_reqrep_example/server.rb
+- examples/simple_zbeacon_example/client.rb
+- examples/simple_zbeacon_example/server.rb
+- examples/zloop_reqrep_example/client.rb
+- examples/zloop_reqrep_example/server.rb
+- examples/zloop_timer_example/zloop_timer.rb
+- lib/czmq.rb
+- lib/czmq/context.rb
+- lib/czmq/version.rb
+- lib/czmq/zbeacon.rb
+- lib/czmq/zframe.rb
+- lib/czmq/zloop.rb
+- lib/czmq/zmsg.rb
+- lib/czmq/zpoller.rb
+- lib/czmq/zsocket.rb
+homepage: https://github.com/mtortonesi/ruby-czmq
+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.2
+signing_key: 
+specification_version: 4
+summary: Ruby gem that provides bindings for the CZMQ library. This is a pure Ruby
+  gem that interfaces with CZMQ using FFI, so it should work under MRI, JRuby, and
+  Rubinius.
+test_files: []