ffi-czmq 0.0.1.pre

data/lib/czmq/zcert.rb

@@ -0,0 +1,56 @@
+require_relative 'utils'
+require_relative 'libczmq'
+
+if CZMQ::Utils.has_curve
+  module CZMQ
+    class Zcert
+      extend ::LibCZMQ
+
+      czmq_constructor
+      czmq_destructor
+
+      czmq_function :public_txt,  :public_txt,  [:pointer],           :string
+      czmq_function :secret_txt,  :secret_txt,  [:pointer],           :string
+      czmq_function :load_zcert,  :load,        [:string],            :pointer
+      czmq_function :save,        :save,        [:pointer, :string],  :int
+      czmq_function :save_public, :save_public, [:pointer, :string],  :int
+      czmq_function :save_secret, :save_secret, [:pointer, :string],  :int
+      czmq_function :apply,       :apply,       [:pointer, :pointer], :void
+      czmq_function :dup_zcert,   :dup,         [:pointer],           :pointer
+      czmq_function :eq,          :eq,          [:pointer, :pointer], :bool
+
+      def self.convert(cert)
+        if Utils.check_for_pointer(cert)
+
+          return cert
+        elsif cert.respond_to?(:to_zcert) &&
+              Utils.check_for_pointer(cert.to_zcert)
+
+          return cert.to_zcert
+        else
+          fail ArgumentError, "#{cert.class} is not a CZMQ::Zcert"
+        end
+      end
+
+      def self.load(filename)
+        unless (zcert = load_zcert(filename)).null?
+          new_from_czmq_obj(zcert)
+        else
+          fail IOError, Utils.error
+        end
+      end
+
+      def dup
+        self.class.new_from_czmq_obj(dup_zcert)
+      end
+
+      def ==(other)
+        eq(self.class.convert(other))
+      end
+
+      def !=(other)
+        ! self.==(other)
+      end
+    end
+  end
+end

data/lib/czmq/zcertstore.rb

@@ -0,0 +1,16 @@
+require_relative 'utils'
+require_relative 'libczmq'
+
+if CZMQ::Utils.has_curve
+  module CZMQ
+    class Zcertstore
+      extend ::LibCZMQ
+
+      czmq_constructor [:string]
+      czmq_destructor
+
+      czmq_function :lookup,        :lookup,  [:pointer, :string],  :pointer
+      czmq_function :insert_zcert,  :insert,  [:pointer, :pointer], :void
+    end
+  end
+end

data/lib/czmq/zconfig.rb

@@ -0,0 +1,69 @@
+require_relative 'libczmq'
+
+module CZMQ
+  class Zconfig
+    extend ::LibCZMQ
+
+    czmq_constructor [:string, :pointer]
+    czmq_destructor
+
+    czmq_function :name,              :name,        [:pointer],                     :string
+    czmq_function :value,             :value,       [:pointer],                     :string
+    czmq_function :put,               :put,         [:pointer, :string, :string],   :void
+    czmq_function :set_name,          :set_name,    [:pointer, :string],            :void
+    czmq_function :set_value,         :set_value,   [:pointer, :string],            :void
+    czmq_function :child_zconfig,     :child,       [:pointer],                     :pointer
+    czmq_function :next_zconfig,      :next,        [:pointer],                     :pointer
+    czmq_function :locate_zconfig,    :locate,      [:pointer, :string],            :pointer
+    czmq_function :resolve,           :resolve,     [:pointer, :string, :string],   :string
+    czmq_function :zconfig_at_depth,  :at_depth,    [:pointer, :int],               :pointer
+    czmq_function :execute_zconfig,   :execute,     [:pointer, :pointer, :pointer], :int
+    czmq_function :set_comment,       :set_comment, [:pointer, :string],            :void
+    czmq_function :load_zconfig,      :load,        [:string],                      :pointer
+    czmq_function :save_zconfig,      :save,        [:pointer, :string],            :int
+    czmq_function :filename,          :filename,    [:pointer],                     :string
+    czmq_function :reload,            :reload,      [:pointer],                     :int
+    czmq_function :has_changed,       :has_changed, [:pointer],                     :bool
+
+    def self.load(filename)
+      unless (zconfig = load_zconfig(filename)).null?
+        new_from_czmq_obj(zconfig)
+      else
+        fail IOError, Utils.error
+      end
+    end
+
+    def child
+      self.class.new_from_czmq_obj(child_zconfig, nil)
+    end
+
+    def next
+      self.class.new_from_czmq_obj(next_zconfig, nil)
+    end
+
+    def execute(&block)
+      zconfig_fct = FFI::Function.new(:int, [:pointer, :pointer, :int], blocking: true) do |zconfig_t, args, level|
+        zconfig = self.class.new_from_czmq_obj(zconfig_t, nil)
+        block.call(zconfig, level)
+      end
+
+      execute_zconfig(zconfig_fct, nil)
+    end
+
+    def locate(path)
+      unless (zconfig = locate_zconfig(path)).null?
+        self.class.new_from_czmq_obj(zconfig, nil)
+      else
+        fail Utils.error
+      end
+    end
+
+    def at_depth(level)
+      unless (zconfig = zconfig_at_depth(level)).null?
+        self.class.new_from_czmq_obj(zconfig, nil)
+      else
+        fail Utils.error
+      end
+    end
+  end
+end

data/lib/czmq/zframe.rb

@@ -0,0 +1,84 @@
+require_relative 'libczmq'
+require_relative 'utils'
+require_relative 'zsock'
+
+module CZMQ
+  class Zframe
+    include Comparable
+    MORE     = 1
+    REUSE    = 2
+    DONTWAIT = 4
+
+    extend ::LibCZMQ
+
+    czmq_constructor [:pointer, :size_t]
+    czmq_destructor
+
+    czmq_function :new_empty_zframe,  :new_empty, [],                             :pointer
+    czmq_function :recv_zframe,       :recv,      [:pointer],                     :pointer
+    czmq_function :send_zframe,       :send,      [:pointer, :pointer, :int],     :int
+    czmq_function :size,              :size,      [:pointer],                     :size_t
+    czmq_function :data,              :data,      [:pointer],                     :pointer
+    czmq_function :dup_zframe,        :dup,       [:pointer],                     :pointer
+    czmq_function :more,              :more,      [:pointer],                     :int
+    czmq_function :set_more,          :set_more,  [:pointer, :int],               :void
+    czmq_function :eq,                :eq,        [:pointer, :pointer],           :bool
+    czmq_function :reset,             :reset,     [:pointer, :pointer, :size_t],  :void
+    czmq_function :print,             :print,     [:pointer, :string],            :void
+
+    def self.new_empty
+      unless (zframe = new_empty_zframe).null?
+        new_from_czmq_obj(zframe)
+      else
+        fail Utils.error
+      end
+    end
+
+    def self.convert(frame)
+      if Utils.check_for_pointer(frame)
+
+        return frame
+      elsif frame.respond_to?(:to_zframe) &&
+            Utils.check_for_pointer(frame.to_zframe)
+
+        return frame.to_zframe
+      else
+        fail ArgumentError, "#{frame.class} is not a CZMQ::Zframe"
+      end
+    end
+
+    def dup
+      self.class.new_from_czmq_obj(dup_zframe)
+    end
+    
+    def more?
+      more & MORE > 0
+    end
+
+    def <=>(other)
+      size <=> other.size
+    end
+
+    def ==(other)
+      (object_id == other.object_id ||eq(self.class.convert(other)))
+    end
+
+    def !=(other)
+      ! self.==(other)
+    end
+
+    def to_str
+      data.read_bytes(size)
+    end
+
+    def self.recv(socket)
+      zsock = Zsock.convert(socket)
+
+      unless (zframe = recv_zframe(zsock)).null?
+        new_from_czmq_obj(zframe)
+      else
+        fail IOError, Utils.error
+      end
+    end
+  end
+end

data/lib/czmq/ziflist.rb

@@ -0,0 +1,38 @@
+require_relative 'libczmq'
+
+module CZMQ
+  class Ziflist
+    include Enumerable
+    extend ::LibCZMQ
+
+    czmq_constructor
+    czmq_destructor
+
+    czmq_function :reload,    :reload,    [:pointer], :void
+    czmq_function :size,      :size,      [:pointer], :size_t
+    czmq_function :first,     :first,     [:pointer], :string
+    czmq_function :next,      :next,      [:pointer], :string
+    czmq_function :address,   :address,   [:pointer], :string
+    czmq_function :broadcast, :broadcast, [:pointer], :string
+    czmq_function :netmask,   :netmask,   [:pointer], :string
+
+    def each
+      yield first
+      size.pred.times do
+        yield self.next
+      end
+    end
+
+    def to_h
+      hsh = {}
+      each do |interface|
+        hsh[interface] = {
+          address:   address,
+          broadcast: broadcast,
+          netmask:   netmask
+        }
+      end
+      hsh
+    end
+  end
+end

data/lib/czmq/zloop.rb

@@ -0,0 +1,54 @@
+require_relative 'libczmq'
+require_relative 'zsock'
+require_relative 'utils'
+
+module CZMQ
+  class Zloop
+    extend ::LibCZMQ
+
+    czmq_constructor
+    czmq_destructor
+
+    czmq_function :reader,        :reader,        [:pointer, :pointer, :pointer, :pointer],         :int
+    czmq_function :reader_end,    :reader_end,    [:pointer, :pointer],                             :void
+    czmq_function :timer,         :timer,         [:pointer, :size_t, :size_t, :pointer, :pointer], :int
+    czmq_function :timer_end,     :timer_end,     [:pointer, :int],                                 :int
+    czmq_function :set_verbose,   :set_verbose,   [:pointer, :bool],                                :void
+    czmq_function :start,         :start,         [:pointer],                                       :int
+
+    def initialize
+      @reader_callbacks = []
+      @timer_callbacks  = []
+    end
+
+    def add_reader(zsock, &block)
+      zloop_reader_fn = FFI::Function.new(:int, [:pointer, :pointer, :pointer], blocking: true) do |zloop_t, zsock_t, args|
+        zsocky = Zsock.new_from_czmq_obj(zsock_t, nil)
+        block.call(zsocky)
+      end
+
+      reader(Zsock.convert(zsock), zloop_reader_fn, nil)
+      @reader_callbacks << {zsock: zsock, zloop_reader_fn: zloop_reader_fn, block: block}
+    end
+
+    def remove_reader(zsock)
+      @reader_callbacks.delete_if {|reader| reader[:zsock] == zsock}
+      reader_end(Zsock.convert(zsock))
+    end
+
+    def add_timer(delay, times, &block)
+      zloop_timer_fn = FFI::Function.new(:int, [:pointer, :int, :pointer], blocking: true) do |zloop_t, timer_id, args|
+        block.call(timer_id)
+      end
+
+      timer_id = timer(delay, times, zloop_timer_fn, nil)
+      @timer_callbacks << {timer_id: timer_id, delay: delay, times: times, zloop_timer_fn: zloop_timer_fn, block: block}
+      timer_id
+    end
+
+    def remove_timer(timer_id)
+      @timer_callbacks.delete_if {|timer| timer[:timer_id] == timer_id}
+      timer_end(timer_id)
+    end
+  end
+end

data/lib/czmq/zmsg.rb

@@ -0,0 +1,175 @@
+require_relative 'libczmq'
+require_relative 'zframe'
+require_relative 'zsock'
+require_relative 'utils'
+
+module CZMQ
+  class Zmsg
+    INTF = '%d'.freeze
+    include Enumerable
+    extend ::LibCZMQ
+
+    czmq_constructor
+    czmq_destructor
+
+    czmq_function :recv_zmsg,         :recv,          [:pointer],                     :pointer
+    czmq_function :send_zmsg,         :send,          [:pointer, :pointer],           :int
+    czmq_function :size,              :size,          [:pointer],                     :size_t
+    czmq_function :content_size,      :content_size,  [:pointer],                     :size_t
+    czmq_function :prepend_zframe,    :prepend,       [:pointer, :pointer],           :int
+    czmq_function :append_zframe,     :append,        [:pointer, :pointer],           :int
+    czmq_function :pop_zframe,        :pop,           [:pointer],                     :pointer
+    czmq_function :push_mem,          :pushmem,       [:pointer, :pointer, :size_t],  :int
+    czmq_function :add_mem,           :addmem,        [:pointer, :pointer, :size_t],  :int
+    czmq_function :push_zstr,         :pushstr,       [:pointer, :string],            :int
+    czmq_function :add_zstr,          :addstr,        [:pointer, :string],            :int
+    czmq_function :push_zstrf,        :pushstrf,      [:pointer, :string, :varargs],  :int
+    czmq_function :add_zstrf,         :addstrf,       [:pointer, :string, :varargs],  :int
+    czmq_function :remove_zframe,     :remove,        [:pointer, :pointer],           :void
+    czmq_function :first_zframe,      :first,         [:pointer],                     :pointer
+    czmq_function :next_zframe,       :next,          [:pointer],                     :pointer
+    czmq_function :last_zframe,       :last,          [:pointer],                     :pointer
+    czmq_function :encode_zmsg,       :encode,        [:pointer, :buffer_in],         :size_t
+    czmq_function :decode_zmsg,       :decode,        [:pointer, :size_t],            :pointer
+    czmq_function :dup_zmsg,          :dup,           [:pointer],                     :pointer
+    czmq_function :print,             :print,         [:pointer],                     :void
+
+    def each
+      yield first
+      size.pred.times do
+        yield self.next
+      end
+    end
+
+    def to_a
+      ary = []
+      each {|frame| ary << frame.to_str }
+      ary
+    end
+
+    def add(data)
+      case data
+      when Zframe
+        append_zframe(data)
+      when String
+        add_string(data)
+      when Integer
+        add_zstrf(INTF, :long, data)
+      when NilClass
+        add_mem(data, 0)
+      else
+        if data.respond_to?(:to_zframe)
+          append_zframe(data.to_zframe)
+        elsif data.respond_to?(:data) &&
+              data.respond_to?(:size)
+
+          add_mem(data.data, data.size)
+        elsif data.respond_to?(:to_str)
+          add_string(data.to_str)
+        elsif data.nil?
+          add_mem(nil, 0)
+        else
+          fail ArgumentError, 'Unknown data type'
+        end
+      end
+      self
+    end
+
+    alias_method :<<, :add
+
+    def push(data)
+      case data
+      when Zframe
+        prepend_zframe(data)
+      when String
+        push_string(data)
+      when Integer
+        push_zstrf(INTF, :long, data)
+      when NilClass
+        push_mem(data, 0)
+      else
+        if data.respond_to?(:to_zframe)
+          prepend_zframe(data.to_zframe)
+        elsif data.respond_to?(:data) &&
+              data.respond_to?(:size)
+
+          push_mem(data.data, data.size)
+        elsif data.respond_to?(:to_str)
+          push_string(data.to_str)
+        elsif data.nil?
+          push_mem(nil, 0)
+        else
+          fail ArgumentError, 'Unknown data type'
+        end
+      end
+      self
+    end
+
+    [:first, :next, :last].each do |meth|
+      class_eval <<-RUBY, __FILE__, __LINE__
+      def #{meth.to_s}
+         CZMQ::Zframe.new_from_czmq_obj(#{meth.to_s}_zframe, nil)
+      end
+      RUBY
+    end
+
+    [:first=, :next=, :last=].each do |meth|
+      class_eval <<-RUBY, __FILE__, __LINE__
+      def #{meth.to_s}(content)
+         CZMQ::Zframe.reset(#{meth.to_s[0...-1]}_zframe, content, content.bytesize)
+      end
+      RUBY
+    end
+
+    def pop
+      Zframe.new_from_czmq_obj(pop_zframe)
+    end
+
+    def dup
+      self.class.new_from_czmq_obj(dup_zmsg)
+    end
+
+    def remove(zframe)
+      remove_zframe(Zframe.convert(zframe))
+    end
+
+    def self.recv(socket)
+      zsock = Zsock.convert(socket)
+
+      unless (zmsg = recv_zmsg(zsock)).null?
+        new_from_czmq_obj(zmsg)
+      else
+        fail IOError, Utils.error
+      end
+    end
+
+    def encode
+      buffer = FFI::MemoryPointer.new(:pointer)
+      size = encode_zmsg(buffer)
+      bPtr = buffer.read_pointer()
+      bPtr.null? ? fail(Utils.error) : bPtr.read_bytes(size)
+    end
+
+    def self.decode(bytes)
+      new_from_czmq_obj(decode_zmsg(bytes, bytes.bytesize))
+    end
+
+    private
+
+    def add_string(string)
+      if string.encoding == Encoding::ASCII_8BIT
+        add_mem(string, string.size)
+      else
+        add_zstr(string)
+      end
+    end
+
+    def push_string(string)
+      if string.encoding == Encoding::ASCII_8BIT
+        push_mem(string, string.size)
+      else
+        push_zstr(string)
+      end
+    end
+  end
+end

data/lib/czmq/zpoller.rb

@@ -0,0 +1,33 @@
+require_relative 'libczmq'
+
+module CZMQ
+  class Zpoller
+    extend ::LibCZMQ
+
+    czmq_constructor [:pointer, :varargs]
+    czmq_destructor
+
+    czmq_function :add,         :add,         [:pointer,  :pointer],  :int
+    czmq_function :remove,      :remove,      [:pointer,  :pointer],  :int
+    czmq_function :wait,        :wait,        [:pointer,  :int],      :pointer
+    czmq_function :expired,     :expired,     [:pointer],             :bool
+    czmq_function :terminated,  :terminated,  [:pointer],             :pointer
+
+    def self.new_poller(*pollitems)
+      zsocks = []
+      pollitems.each do |pollitem|
+        zsocks << Zsock.convert(pollitem)
+      end
+      case zsocks.size
+      when 0
+        fail ArgumentError, 'wrong number of arguments (0 for 1..n)'
+      when 1
+        new(zsocks.first, :pointer, nil)
+      else
+        first_sock = zsocks.delete(zsocks.first)
+        other_socks = ([ :pointer ] * zsocks.size).zip(zsocks).flatten
+        new(first_sock, *other_socks, :pointer, nil)
+      end
+    end
+  end
+end

data/lib/czmq/zsock.rb

@@ -0,0 +1,125 @@
+require_relative 'libczmq'
+require_relative 'utils'
+require_relative 'sock_type'
+require_relative 'zmsg'
+
+module CZMQ
+  class Zsock
+    SET_SOCKOPT = /^set_(.+)$/.freeze
+
+    extend ::LibCZMQ
+
+    czmq_constructor
+    czmq_destructor
+
+    czmq_function :bind,        :bind,      [:pointer, :string],        :int
+    czmq_function :endpoint,    :endpoint,  [:pointer],                 :string
+    czmq_function :unbind,      :unbind,    [:pointer, :string],        :int
+    czmq_function :connect,     :connect,   [:pointer, :string],        :int
+    czmq_function :disconnect,  :disconnect,[:pointer, :string],        :int
+    czmq_function :attach,      :attach,    [:pointer, :string, :bool], :int
+    czmq_function :type_str,    :type_str,  [:pointer],                 :string
+    czmq_function :signal,      :signal,    [:pointer, :uchar],         :int
+    czmq_function :wait,        :wait,      [:pointer],                 :int
+    czmq_function :resolve,     :resolve,   [:pointer],                 :pointer
+
+    def self.convert(czmq_obj)
+      if Utils.check_for_pointer(czmq_obj)
+
+        return czmq_obj
+      elsif czmq_obj.respond_to?(:to_zsock) &&
+            Utils.check_for_pointer(czmq_obj.to_zsock)
+
+        return czmq_obj.to_zsock
+      elsif czmq_obj.respond_to?(:to_zactor) &&
+            Utils.check_for_pointer(czmq_obj.to_zactor)
+
+        return czmq_obj.to_zactor
+      else
+        fail ArgumentError, "#{czmq_obj.class} is not a CZMQ::Zsock or CZMQ::Zactor"
+      end
+    end
+
+    [:rep, :router, :pull, :pub, :xpub].each do |meth|
+      instance_eval <<-RUBY, __FILE__, __LINE__
+      def new_#{meth.to_s}(endpoints)
+        sock = new(#{meth.inspect}, endpoints)
+        sock.attach(endpoints, true)
+        sock
+      end
+      RUBY
+    end
+
+    [:req, :dealer, :push, :xsub, :pair, :stream].each do |meth|
+      instance_eval <<-RUBY, __FILE__, __LINE__
+      def new_#{meth.to_s}(endpoints)
+        sock = new(#{meth.inspect}, endpoints)
+        sock.attach(endpoints, false)
+        sock
+      end
+      RUBY
+    end
+
+    def self.new_sub(endpoints, *subscriptions)
+      sock = new(:sub, endpoints, *subscriptions)
+      sock.attach(endpoints, false)
+      subscriptions.each do |subscription|
+        sock.set_subscribe(subscription)
+      end
+      sock
+    end
+
+    def tell(*msgs)
+      zmsg = Zmsg.new
+      msgs.each {|msg| zmsg << msg}
+      forward(zmsg)
+    end
+
+    alias_method :<<, :tell
+
+    def forward(zmsg)
+      zmsg.send_zmsg(@czmq_obj)
+    end
+
+    def recv
+      Zmsg.recv(@czmq_obj)
+    end
+
+    def method_missing(meth, *args, &blk)
+      if args.length == 1 &&
+         meth.to_s =~ SET_SOCKOPT &&
+         (args.first.is_a?(Integer) || args.first.is_a?(String))
+        begin
+
+          self.class.instance_eval <<-RUBY, __FILE__, __LINE__
+          attach_function #{meth.inspect}, "zsock_#{meth.to_s}", [:pointer, :varargs], :void
+          RUBY
+
+        rescue FFI::NotFoundError
+          super
+        else
+
+          if args.first.is_a?(Integer)
+            self.class.class_eval <<-RUBY, __FILE__, __LINE__
+            def #{meth.to_s}(arg)
+              self.class.#{meth.to_s}(@czmq_obj, :int, arg)
+            end
+            RUBY
+          elsif args.first.is_a?(String)
+            self.class.class_eval <<-RUBY, __FILE__, __LINE__
+            def #{meth.to_s}(arg)
+              self.class.#{meth.to_s}(@czmq_obj, :string, arg)
+            end
+            RUBY
+          end
+
+          send meth, args.first
+
+        end
+      else
+        super
+      end
+
+    end
+  end
+end

data/lib/czmq/zsys.rb

@@ -0,0 +1,40 @@
+require_relative 'libczmq'
+
+module CZMQ
+  class Zsys
+    extend ::LibCZMQ
+
+    czmq_function :init,            :init,            [],         :pointer
+    czmq_function :handler_set,     :handler_set,     [:pointer], :void
+    czmq_function :handler_reset,   :handler_reset,   [],         :void
+    czmq_function :set_io_threads,  :set_io_threads,  [:size_t],  :void
+    czmq_function :set_max_sockets, :set_max_sockets, [:size_t],  :void
+    czmq_function :socket_limit,    :socket_limit,    [],         :size_t
+    czmq_function :set_linger,      :set_linger,      [:size_t],  :void
+    czmq_function :set_sndhwm,      :set_sndhwm,      [:size_t],  :void
+    czmq_function :set_rcvhwm,      :set_rcvhwm,      [:size_t],  :void
+    czmq_function :set_pipehwm,     :set_pipehwm,     [:size_t],  :void
+    czmq_function :pipehwm,         :pipehwm,         [],         :size_t
+    czmq_function :set_ipv6,        :set_ipv6,        [:int],     :void
+    czmq_function :set_interface,   :set_interface,   [:string],  :void
+    czmq_function :set_logident,    :set_logident,    [:string],  :void
+    czmq_function :set_logstream,   :set_logstream,   [:pointer], :void
+    czmq_function :set_logsender,   :set_logsender,   [:string],  :void
+    czmq_function :set_logsystem,   :set_logsystem,   [:bool],    :void
+    czmq_function :error,           :error,           [:string],  :void
+    czmq_function :warning,         :warning,         [:string],  :void
+    czmq_function :notice,          :notice,          [:string],  :void
+    czmq_function :info,            :info,            [:string],  :void
+    czmq_function :debug,           :debug,           [:string],  :void
+
+    attach_variable :interrupted, :zsys_interrupted, :int
+    attach_variable :zctx_interrupted, :zctx_interrupted, :int
+
+    handler_set(nil)
+    set_ipv6(1)
+
+    at_exit do
+      zctx_interrupted = interrupted = 1
+    end
+  end
+end