zmachine 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zmachine.gemspec
+gemspec
+
+gem 'ruby-debug'
+gem 'ruby-debug-ide'
+gem 'brice'
+gem 'awesome_print'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Benedikt Böhm
+
+MIT License
+
+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,29 @@
+# Zmachine
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zmachine'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zmachine
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/echo_client.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'zmachine'
+
+java_import org.zeromq.ZMQ
+java_import org.zeromq.ZMsg
+java_import org.zeromq.ZFrame
+
+#set_trace_func proc { |event, file, line, id, binding, classname|
+#  printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+#}
+
+$i = 0
+
+class ZMQEcho < ZMachine::Connection
+  def connection_completed
+    send_msg
+  end
+
+  def receive_data(data)
+    puts "recv(#{data.to_a.map {|f| String.from_java_bytes(f.data) }.inspect})"
+    send_msg
+  end
+
+  def send_msg
+    msg = ZMsg.new_string_msg($i.to_s)
+    msg.wrap(ZFrame.new("server"))
+    send_data(msg)
+    $i += 1
+  end
+end
+
+class TCPEcho < ZMachine::Connection
+  def connection_completed
+    send_data(Time.now.to_s)
+    sleep(0.5)
+  end
+
+  def receive_data(data)
+    puts "receive_data(#{data.inspect})"
+    send_data(Time.now.to_s)
+  end
+end
+
+ZMachine.run {
+  ZMachine.connect("tcp://127.0.0.1:10000", ZMQ::ROUTER, ZMQEcho) do |handler|
+    handler.channel.identity = "client"
+  end
+  #ZMachine.connect("127.0.0.1", 10000, TCPEcho)
+}
+
+#ctx = ZContext.new
+#socket = ctx.create_socket(ZMQ::ROUTER)
+#socket.connect("tcp://127.0.0.1:10000")
+#socket.identity = "client".to_java_bytes
+
+#sleep(1)
+
+#loop do
+#  msg = ZMsg.new_string_msg($i.to_s)
+#  msg.wrap(ZFrame.new("server"))
+#  msg.java_send(:send, [org.zeromq.ZMQ::Socket], socket)
+#  $i += 1
+#  break if $i > 100
+#  #puts ZMsg.recvMsg(socket).inspect
+#end
+
+#socket.close
+#ctx.destroy

data/echo_server.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'zmachine'
+
+java_import org.zeromq.ZMQ
+java_import org.zeromq.ZFrame
+
+#set_trace_func proc { |event, file, line, id, binding, classname|
+#  printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+#}
+
+class EchoServer < ZMachine::Connection
+  def receive_data(msg)
+    origin = msg.unwrap
+    puts "recv(#{msg.to_a.map {|f| String.from_java_bytes(f.data) }.inspect})"
+    msg = ZMsg.new_string_msg("ok")
+    msg.wrap(origin)
+    send_data(msg)
+  end
+end
+
+ZMachine.run do
+  ZMachine.start_server("tcp://*:10000", ZMQ::ROUTER, EchoServer) do |handler|
+    handler.channel.identity = "server"
+  end
+  #ZMachine.start_server("0.0.0.0", 10000, EchoServer)
+  puts "machine running"
+end
+
+#ctx = ZContext.new
+#socket = ctx.create_socket(ZMQ::ROUTER)
+#socket.bind("tcp://127.0.0.1:10000")
+#socket.identity = "server".to_java_bytes
+
+#loop do
+#  puts socket.events.inspect
+#  msg = ZMsg.recvMsg(socket)
+#  puts "recv(#{msg.to_a.map {|f| String.from_java_bytes(f.data) }.inspect})"
+#end

data/lib/zmachine/acceptor.rb

@@ -0,0 +1,12 @@
+module ZMachine
+  class Acceptor
+    attr_reader :klass
+    attr_reader :args
+    attr_reader :callback
+
+    def initialize(channel, klass, *args, &block)
+      @klass, @args, @callback = klass, args, block
+    end
+
+  end
+end

data/lib/zmachine/channel.rb

@@ -0,0 +1,14 @@
+module ZMachine
+  class Channel
+
+    attr_reader :socket
+    attr_reader :selector
+    attr_accessor :handler
+
+    def initialize(selector)
+      @selector = selector
+      @outbound_queue = []
+    end
+
+  end
+end

data/lib/zmachine/connection.rb

@@ -0,0 +1,186 @@
+module ZMachine
+  class Connection
+
+    attr_accessor :channel
+
+    extend Forwardable
+
+    alias original_method method
+
+    def self.new(channel, *args, &block)
+      allocate.instance_eval do
+        @channel = channel
+        initialize(*args, &block)
+        post_init
+        self
+      end
+    end
+
+    def initialize(*args, &block)
+    end
+
+    # callbacks
+
+    def post_init
+    end
+
+    def connection_completed
+    end
+
+    def receive_data(data)
+    end
+
+    def unbind
+    end
+
+    # public API
+
+    def_delegator :@channel, :close_connection
+
+    def close_connection_after_writing
+      close_connection(true)
+    end
+
+    def comm_inactivity_timeout
+    end
+
+    def comm_inactivity_timeout=(value)
+    end
+
+    alias :set_comm_inactivity_timeout :comm_inactivity_timeout=
+
+    def detach
+      _not_implemented
+    end
+
+    def error?
+      errno = ZMachine::report_connection_error_status(@signature)
+      case errno
+      when 0
+        false
+      when -1
+        true
+      else
+        Errno::constants.select do |name|
+          Errno.__send__(:const_get, name)::Errno == errno
+        end.first
+      end
+    end
+
+    def get_idle_time
+      _not_implemented
+    end
+
+    def get_peer_cert
+      _not_implemented
+    end
+
+    def get_peername
+      if peer = @channel.peer_name
+        ::Socket.pack_sockaddr_in(*peer)
+      end
+    end
+
+    def get_pid
+      _not_implemented
+    end
+
+    def get_proxied_bytes
+      _not_implemented
+    end
+
+    def_delegator :@channel, :get_sock_opt
+
+    def get_sockname
+      if sock_name = @channel.sock_name
+        ::Socket.pack_sockaddr_in(*sock_name)
+      end
+    end
+
+    def get_status
+    end
+
+    def notify_readable=(mode)
+      _not_implemented
+    end
+
+    def notify_readable?
+      _not_implemented
+    end
+
+    def notify_writable=(mode)
+      _not_implemented
+    end
+
+    def notify_writable?
+      _not_implemented
+    end
+
+    def pause
+      _not_implemented
+    end
+
+    def paused?
+      _not_implemented
+    end
+
+    def pending_connect_timeout=(value)
+    end
+
+    alias :set_pending_connect_timeout :pending_connect_timeout=
+
+    def proxy_completed
+      _not_implemented
+    end
+
+    def proxy_incoming_to(conn, bufsize = 0)
+      _not_implemented
+    end
+
+    def proxy_target_unbound
+      _not_implemented
+    end
+
+    def resume
+      _not_implemented
+    end
+
+    def_delegator :@channel, :send_data
+
+    def send_datagram(data, recipient_address, recipient_port)
+      _not_implemented
+    end
+
+    def send_file_data(filename)
+      _not_implemented
+    end
+
+    def_delegator :@channel, :set_sock_opt
+
+    def ssl_handshake_completed
+      _not_implemented
+    end
+
+    def ssl_verify_peer(cert)
+      _not_implemented
+    end
+
+    def start_tls(args = {})
+      _not_implemented
+    end
+
+    def stop_proxying
+      _not_implemented
+    end
+
+    def stream_file_data(filename, args = {})
+      _not_implemented
+    end
+
+    private
+
+    def _not_implemented
+      raise RuntimeError.new("API call not implemented!")
+    end
+  end
+end

data/lib/zmachine/deferrable.rb

@@ -0,0 +1,207 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
+#
+# See ZMachine and ZMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+#
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module ZMachine
+  module Deferrable
+    autoload :Pool, 'em/deferrable/pool'
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :succeeded. See #set_deferred_status for more information.
+    #
+    # Calling this method on a Deferrable object whose status is not yet known
+    # will cause the callback block to be stored on an internal list.
+    # If you call this method on a Deferrable whose status is :succeeded, the
+    # block will be executed immediately, receiving the parameters given to the
+    # prior #set_deferred_status call.
+    #
+    #--
+    # If there is no status, add a callback to an internal list.
+    # If status is succeeded, execute the callback immediately.
+    # If status is failed, do nothing.
+    #
+    def callback(&block)
+      return unless block
+      @deferred_status ||= :unknown
+      if @deferred_status == :succeeded
+        block.call(*@deferred_args)
+      elsif @deferred_status != :failed
+        @callbacks ||= []
+        @callbacks.unshift(block) # << block
+      end
+      self
+    end
+
+    # Cancels an outstanding callback to &block if any. Undoes the action of #callback.
+    #
+    def cancel_callback(block)
+      @callbacks ||= []
+      @callbacks.delete(block)
+    end
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :failed. See #set_deferred_status for more information.
+    #--
+    # If there is no status, add an errback to an internal list.
+    # If status is failed, execute the errback immediately.
+    # If status is succeeded, do nothing.
+    #
+    def errback(&block)
+      return unless block
+      @deferred_status ||= :unknown
+      if @deferred_status == :failed
+        block.call(*@deferred_args)
+      elsif @deferred_status != :succeeded
+        @errbacks ||= []
+        @errbacks.unshift(block) # << block
+      end
+      self
+    end
+
+    # Cancels an outstanding errback to &block if any. Undoes the action of #errback.
+    #
+    def cancel_errback(block)
+      @errbacks ||= []
+      @errbacks.delete(block)
+    end
+
+    # Sets the "disposition" (status) of the Deferrable object. See also the large set of
+    # sugarings for this method.
+    # Note that if you call this method without arguments,
+    # no arguments will be passed to the callback/errback.
+    # If the user has coded these with arguments, then the
+    # user code will throw an argument exception.
+    # Implementors of deferrable classes <b>must</b>
+    # document the arguments they will supply to user callbacks.
+    #
+    # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
+    # on the INSIDE of a callback. This is very useful when a previously-registered
+    # callback wants to change the parameters that will be passed to subsequently-registered
+    # ones.
+    #
+    # You may give either :succeeded or :failed as the status argument.
+    #
+    # If you pass :succeeded, then all of the blocks passed to the object using the #callback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using #errback will be discarded.
+    #
+    # If you pass :failed, then all of the blocks passed to the object using the #errback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using # callback will be discarded.
+    #
+    # If you pass any arguments to #set_deferred_status in addition to the status argument,
+    # they will be passed as arguments to any callbacks or errbacks that are executed.
+    # It's your responsibility to ensure that the argument lists specified in your callbacks and
+    # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
+    # an ArgumentError.
+    #
+    #--
+    # We're shifting callbacks off and discarding them as we execute them.
+    # This is valid because by definition callbacks are executed no more than
+    # once. It also has the magic effect of permitting recursive calls, which
+    # means that a callback can call #set_deferred_status and change the parameters
+    # that will be sent to subsequent callbacks down the chain.
+    #
+    # Changed @callbacks and @errbacks from push/shift to unshift/pop, per suggestion
+    # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
+    # versions.
+    #
+    # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
+    # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
+    # which only allows status to be set once. Prior to making this change, it was possible
+    # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
+    # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
+    # to raise an exception is status is set more than once on a Deferrable. The latter
+    # behavior would invalidate the idiom of resetting arguments by setting status from
+    # within a callback or errback, but more seriously it would cause spurious errors
+    # if a Deferrable was timed out and then an attempt was made to succeed it. See the
+    # comments under the new method #timeout.
+    #
+    def set_deferred_status(status, *args)
+      cancel_timeout
+      @errbacks ||= nil
+      @callbacks ||= nil
+      @deferred_status = status
+      @deferred_args = args
+      case @deferred_status
+      when :succeeded
+        if @callbacks
+          while cb = @callbacks.pop
+            cb.call(*@deferred_args)
+          end
+        end
+        @errbacks.clear if @errbacks
+      when :failed
+        if @errbacks
+          while eb = @errbacks.pop
+            eb.call(*@deferred_args)
+          end
+        end
+        @callbacks.clear if @callbacks
+      end
+    end
+
+    # Setting a timeout on a Deferrable causes it to go into the failed state after
+    # the Timeout expires (passing no arguments to the object's errbacks).
+    # Setting the status at any time prior to a call to the expiration of the timeout
+    # will cause the timer to be cancelled.
+    def timeout(seconds, *args)
+      cancel_timeout
+      me = self
+      @deferred_timeout = ZMachine::Timer.new(seconds) { me.fail(*args) }
+      self
+    end
+
+    # Cancels an outstanding timeout if any. Undoes the action of #timeout.
+    #
+    def cancel_timeout
+      @deferred_timeout ||= nil
+      if @deferred_timeout
+        @deferred_timeout.cancel
+        @deferred_timeout = nil
+      end
+    end
+
+    # Sugar for set_deferred_status(:succeeded, ...)
+    #
+    def succeed(*args)
+      set_deferred_status(:succeeded, *args)
+    end
+    alias set_deferred_success succeed
+
+    # Sugar for set_deferred_status(:failed, ...)
+    #
+    def fail(*args)
+      set_deferred_status(:failed, *args)
+    end
+    alias set_deferred_failure fail
+  end
+
+  # DefaultDeferrable is an otherwise empty class that includes Deferrable.
+  # This is very useful when you just need to return a Deferrable object
+  # as a way of communicating deferred status to some other part of a program.
+  class DefaultDeferrable
+    include Deferrable
+  end
+end