zy 0.0.1.alfa

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a13b474a2570c278d2cd7e81a9ae5837f760ac47
+  data.tar.gz: df95600d55da2e70d543dc414107616a7340d697
+SHA512:
+  metadata.gz: 13ee3b9b683efe52dcbc9a15f6a7d256876b8b3edc076080551b3f4689f3d2a1aaf2c443ff69327a4cffa1ee8146a74a8096d492a2e64cb157cbb5cf92ec61e4
+  data.tar.gz: f15c7ab8febd69ffa1f031f32080306e5893fd3b3e849e003bbecf47ff14946734501392c73509a8ebc3dcd61905a295ed90497eec91761f6f51136bd3bc2b6a

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ethan
+
+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,55 @@
+# Zy
+
+Zy is an application level protocol, defining a structure for requests and replies to a service. It draws from concepts of REST over HTTP.
+
+It encodes its structure as JSON, and is intended to be transported over ØMQ (ZeroMQ).
+
+A request from a client consists of a message with two frames, and an example looks like:
+
+```
+zy 0.0 json
+```
+
+```json
+{
+  "resource": "events",
+  "action": "update",
+  "params": {
+    "name": "2004 summer olympics"
+  },
+  "body": {
+    "location": "Athens, Greece"
+  }
+}
+```
+
+The first frame is called the protocol frame and sets up the basics, telling the server that the client is speaking the zy protocol, version 0.0. It indicates that the following message is formatted as JSON (JSON is currently the only supported format).
+
+The next frame is the JSON-formatted request. It includes these fields:
+
+- resource: the name of the resource. this is analagous to the request path or URI in HTTP.
+- action: the action to be performed. this is analagous to the request method in HTTP.
+- params: parameters of the request. in this case specifying the identity of the resource in question.
+- body: the main message which the server will act on. may not always be specified.
+
+A reply to this also consists of two frames and might look like:
+
+```
+zy 0.0 json
+```
+
+```json
+{
+  "status": ["success", "update"],
+  "body": {
+    "name": "2004 summer olympics",
+    "location": "Athens, Greece",
+    "year": "2004"
+  }
+}
+```
+
+The protocol frame is the same. The reply frame has these fields:
+
+- status: an array of strings, each being a short word to identify aspects of the status, in decreasing order of specificity. this is conceptually similar to an HTTP status code, but is human-readable and allows for more precision.
+- body: the main message of the response to be conveyed back to the requester. may not always be specified - in this case, for example, it may have been omitted on the assumption that the client knows the identified resource and does not need a representation of it in the reply after the update.

data/Rakefile.rb

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.name = 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+task 'default' => 'test'

data/lib/zy.rb

@@ -0,0 +1,40 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path(File.dirname(__FILE__)))
+
+require 'zy/version'
+
+require 'ffi-rzmq'
+require 'json'
+
+module Zy
+  class Error < StandardError
+  end
+
+  class << self
+    def zmq_context
+      @zmq_context ||= begin
+        ZMQ::Context.new.tap do |zmq_context|
+          trap("INT") do
+            STDERR.puts "goodbye!"
+            zmq_context.terminate
+            STDERR.puts "ok exiting"
+            exit 0
+            STDERR.puts "done"
+          end
+        end
+      end
+    end
+
+    def zmq_context=(zmq_context)
+      if @zmq_context
+        raise Zy::Error, "zmq_context is already set"
+      else
+        @zmq_context = zmq_context
+      end
+    end
+  end
+
+  autoload :Server, 'zy/server'
+  autoload :Request, 'zy/request'
+  autoload :Reply, 'zy/reply'
+  autoload :Natra, 'zy/natra'
+end

data/lib/zy/natra.rb

@@ -0,0 +1,50 @@
+module Zy
+  class Natra
+    def self.inherited(klass)
+      klass.instance_variable_set(:@constraints, {})
+      klass.instance_variable_set(:@handlers, [])
+    end
+
+    module HandlerContext
+      def with_constraints(constraints, &block)
+        # keys and values: symbols become strings
+        constraints = constraints.map { |k,v| {k.is_a?(Symbol) ? k.to_s : k => v.is_a?(Symbol) ? v.to_s : v} }.inject({}, &:update)
+        begin
+          original_constraints = @constraints
+          @constraints = @constraints.merge(constraints)
+          yield
+        ensure
+          @constraints = original_constraints
+        end
+      end
+
+      def resource(name, &block)
+        with_constraints(:resource => name, &block)
+      end
+
+      def action(name = nil, &block)
+        if name
+          with_constraints(:action => name) { action(&block) }
+        else
+          @handlers << [@constraints, block]
+        end
+      end
+    end
+
+    extend HandlerContext
+
+    def self.call(request)
+      _, handler = @handlers.detect do |(constraints, action_block)|
+        constraints.all? do |key, value|
+          request[key] == value
+        end
+      end
+
+      if handler
+        handler.call(request)
+      else
+        {'status' => ['error', 'request', 'unroutable']}
+      end
+    end
+  end
+end

data/lib/zy/reply.rb

@@ -0,0 +1,30 @@
+module Zy
+  class Reply
+    class << self
+      def from(reply_object)
+        reply_object.is_a?(self) ? reply_object : new(reply_object)
+      end
+    end
+
+    def initialize(object)
+      @object = object
+    end
+
+    def reply_strings
+      @reply_strings ||= [protocol_string, reply_string]
+    end
+
+    def protocol_string
+      'zy 0.0 json'
+    end
+
+    def reply_string
+      begin
+        JSON.generate(@object)
+      rescue JSON::GeneratorError
+        # TODO log debug
+        JSON.generate({"status" => ["error", "server", "internal_error"]})
+      end
+    end
+  end
+end

data/lib/zy/request.rb

@@ -0,0 +1,71 @@
+require 'json'
+
+module Zy
+  class Request
+    def initialize(request_strings)
+      @request_strings = request_strings
+      @error_status = catch(:error) do
+        # this should not happen; it's not possible to get a 0-frame message in zmq
+        throw(:error, ['error', 'request', 'no_frames']) if @request_strings.size < 1
+
+        @protocol_string = @request_strings[0]
+        @protocol_parts = @protocol_string.strip.split(/ +/)
+
+        # protocol part 0: protocol name (zy)
+        part = 0
+        if @protocol_parts.size <= part
+          throw(:error, ['error', 'protocol', 'protocol_name_not_specified'])
+        elsif @protocol_parts[part] != 'zy'
+          throw(:error, ['error', 'protocol', 'protocol_not_supported'])
+        end
+
+        # protocol part 1: version
+        part = 1
+        if @protocol_parts.size <= part
+          throw(:error, ['error', 'protocol', 'version_not_specified'])
+        elsif @protocol_parts[part] != '0.0'
+          throw(:error, ['error', 'protocol', 'version_not_supported'])
+        end
+
+        # protocol part 2: format
+        part = 2
+        if @protocol_parts.size <= part
+          throw(:error, ['error', 'protocol', 'format_not_specified'])
+        elsif @protocol_parts[part] != 'json'
+          throw(:error, ['error', 'protocol', 'format_not_supported'])
+        end
+
+        # protocol part(s) we don't recognize
+        part = 3
+        if @protocol_parts.size > part
+          throw(:error, ['error', 'protocol', 'too_many_parts'])
+        end
+
+        if @request_strings.size < 2
+          throw(:error, ['error', 'request', 'request_not_specified'])
+        end
+
+        @request_string = @request_strings[1]
+
+        if @request_strings.size > 2
+          throw(:error, ['error', 'request', 'too_many_frames'])
+        end
+
+        begin
+          @object = JSON.parse(@request_string)
+        rescue JSON::ParserError
+          throw(:error, ['error', 'request', 'not_in_specified_format'])
+        end
+
+        throw(:error, ['error', 'request', 'not_object']) unless @object.is_a?(Hash)
+      end
+    end
+
+    attr_reader :error_status
+    attr_reader :object
+
+    def [](key)
+      @object[key]
+    end
+  end
+end

data/lib/zy/server.rb

@@ -0,0 +1,101 @@
+module Zy
+  class ServerError < Error
+  end
+
+  class Server
+    # options may include:
+    #
+    # - app
+    # - bind
+    # - connect
+    # - server_private_key
+    def initialize(options)
+      # stringify symbol keys
+      @options = options.map { |k,v| {k.is_a?(Symbol) ? k.to_s : k => v} }.inject({}, &:update)
+    end
+
+    def app
+      @options['app']
+    end
+
+    def start
+      debug({:server_socket => 'creating'})
+      server_socket = Zy.zmq_context.socket(ZMQ::REP)
+      debug({:server_socket => 'created (ZMQ::REP)'})
+      raise(ServerError, "failed to create socket") unless server_socket
+
+      if @options['server_private_key']
+        debug({:server_socket => {:curve => 'setting to server'}})
+        rc = server_socket.setsockopt(ZMQ::CURVE_SERVER, 1)
+        debug({:server_socket => {:curve => 'set to server'}})
+        raise(ServerError, "failed to set server socket to curve server (errno = #{ZMQ::Util.errno})") if rc < 0
+        debug({:server_socket => {:curve => 'setting private key'}})
+        rc = server_socket.setsockopt(ZMQ::CURVE_SECRETKEY, @options['server_private_key'])
+        debug({:server_socket => {:curve => 'set private key'}})
+        raise(ServerError, "failed to set server socket curve secret key (errno = #{ZMQ::Util.errno})") if rc < 0
+      else
+        debug({:server_socket => {:curve => 'private key not specified'}})
+      end
+
+      if @options['bind']
+        debug({:server_socket => "binding #{@options['bind']}"})
+        bind_rc = server_socket.bind(@options['bind'])
+        debug({:server_socket => "bound #{@options['bind']}"})
+        raise(ServerError, "failed to bind server socket to #{@options['bind']} (errno = #{ZMQ::Util.errno})") if bind_rc < 0
+      elsif @options['connect']
+        debug({:server_socket => "connecting #{@options['connect']}"})
+        connect_rc = server_socket.connect(@options['connect'])
+        debug({:server_socket => "connected #{@options['connect']}"})
+        raise(ServerError, "failed to connect server socket to #{@options['connect']} (errno = #{ZMQ::Util.errno})") if connect_rc < 0
+      else
+        raise(ServerError, "must specify bind or connect address")
+      end
+
+      loop do
+        debug({:server_socket => "ready to recv"})
+        request_strings = []
+        more = true
+        while more
+          request_message = ZMQ::Message.create || raise(ServerError, "failed to create message (errno = #{ZMQ::Util.errno})")
+          recv_rc = server_socket.recvmsg(request_message)
+          debug({:server_socket => "recvd (#{recv_rc})"})
+          raise(ServerError, "server socket failed to recv (errno = #{ZMQ::Util.errno})") if recv_rc < 0
+          request_strings << request_message.copy_out_string
+          debug({:server_socket => "copied #{request_strings.last}"})
+          request_message.close
+          more = server_socket.more_parts?
+        end
+        request = Request.new(request_strings)
+        if request.error_status
+          reply_obj = {'status' => request.error_status}
+        else
+          begin
+            reply_obj = app.call(request)
+          rescue Exception => e
+            debug({exception: {class: e.class, message: e.message, backtrace: e.backtrace}})
+            reply_obj = {"status" => ["error", "server", "internal_error"]}
+          end
+        end
+        reply = Reply.from(reply_obj)
+        reply.reply_strings.each_with_index do |reply_s, i|
+          flags = i < reply.reply_strings.size - 1 ? ZMQ::SNDMORE : 0
+          debug({:server_socket => "sending #{reply_s} (flags=#{flags})"})
+          send_rc = server_socket.send_string(reply_s, flags)
+          debug({:server_socket => "sent (#{send_rc})"})
+          raise(ServerError, "server socket failed to send (errno = #{ZMQ::Util.errno})") if send_rc < 0
+        end
+      end
+    end
+
+    def logger
+      @logger ||= @options['logger'] || begin
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def debug(message)
+      logger.debug JSON.generate message
+    end
+  end
+end

data/lib/zy/version.rb

@@ -0,0 +1,3 @@
+module Zy
+  VERSION = '0.0.1.alfa'
+end

data/test/basic_interaction_test.rb

@@ -0,0 +1,130 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+describe(Zy::Server) do
+  before do
+    server = TCPServer.new('127.0.0.1', 0)
+    @server_port = server_port = server.addr[1]
+    server.close
+
+    STDERR.puts "firing server"
+    Thread.abort_on_exception = true
+    @server_thread = Thread.new do
+      Zy::Server.new(
+        :app => app,
+        :bind => "tcp://*:#{server_port}",
+      ).start
+    end
+    STDERR.puts "fired server"
+  end
+  after do
+    @server_thread.kill
+  end
+
+  let(:app) do
+    proc { |request| {} }
+  end
+
+  let(:client_socket) do
+    Zy.zmq_context.socket(ZMQ::REQ).tap do |client_socket|
+      client_socket.connect("tcp://localhost:#{@server_port}")
+    end
+  end
+
+  def request_s(*request_strings)
+    request_strings.each_with_index do |request_s, i|
+      flags = i < request_strings.size - 1 ? ZMQ::SNDMORE : 0
+      send_rc = client_socket.send_string(request_s, flags)
+      assert(send_rc >= 0)
+    end
+    reply_strings = []
+    more = true
+    while more
+      reply_message = ZMQ::Message.create || raise(ServerError, "failed to create message (errno = #{ZMQ::Util.errno})")
+      recv_rc = client_socket.recvmsg(reply_message)
+      assert(recv_rc >= 0)
+      reply_strings << reply_message.copy_out_string
+      reply_message.close
+      more = client_socket.more_parts?
+    end
+    assert_equal(2, reply_strings.size)
+    assert_equal('zy 0.0 json', reply_strings[0])
+    JSON.parse(reply_strings[1])
+  end
+
+  it 'requests and replies' do
+    reply_s = request_s('zy 0.0 json', '{}')
+  end
+
+  describe 'internal server error' do
+    let(:app) do
+      proc { |request| raise }
+    end
+
+    it 'internal server errors' do
+      reply = request_s('zy 0.0 json', '{}')
+      assert_equal({'status' => ['error', 'server', 'internal_error']}, reply)
+    end
+  end
+
+  describe 'reply object not jsonable' do
+    let(:app) do
+      proc { |request| Object.new }
+    end
+
+    it 'internal server errors' do
+      reply = request_s('zy 0.0 json', '{}')
+      assert_equal({'status' => ['error', 'server', 'internal_error']}, reply)
+    end
+  end
+
+  it 'rejects non-json' do
+    reply = request_s('zy 0.0 json', 'hello!')
+    assert_equal({'status' => ['error', 'request', 'not_in_specified_format']}, reply)
+  end
+
+  it 'rejects non-object in json' do
+    reply = request_s('zy 0.0 json', '["a request"]')
+    assert_equal({'status' => ['error', 'request', 'not_object']}, reply)
+  end
+
+  it 'rejects missing request frame' do
+    reply = request_s('zy 0.0 json')
+    assert_equal({'status' => ['error', 'request', 'request_not_specified']}, reply)
+  end
+
+  it 'rejects too many frames' do
+    reply = request_s('zy 0.0 json', '{}', '{}')
+    assert_equal({'status' => ['error', 'request', 'too_many_frames']}, reply)
+  end
+
+  it 'rejects missing format' do
+    reply = request_s('zy 0.0', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'format_not_specified']}, reply)
+  end
+
+  it 'rejects missing version' do
+    reply = request_s('zy', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'version_not_specified']}, reply)
+  end
+
+  it 'rejects missing protocol' do
+    reply = request_s('', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'protocol_name_not_specified']}, reply)
+  end
+
+  it 'rejects unrecognized format' do
+    reply = request_s('zy 0.0 xml', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'format_not_supported']}, reply)
+  end
+
+  it 'rejects unsupported version' do
+    reply = request_s('zy 9.0 json', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'version_not_supported']}, reply)
+  end
+
+  it 'rejects wrong protocol' do
+    reply = request_s('http 0.0 json', '{}')
+    assert_equal({'status' => ['error', 'protocol', 'protocol_not_supported']}, reply)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
+
+# NO EXPECTATIONS 
+ENV["MT_NO_EXPECTATIONS"] = ''
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require 'zy'

data/zy.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.any? { |lp| File.expand_path(lp) == File.expand_path(lib) }
+require 'zy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'zy'
+  spec.version       = Zy::VERSION
+  spec.authors       = ['Ethan']
+  spec.email         = ['ethan@unth']
+  spec.summary       = 'zy'
+  spec.description   = 'zy'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0") - ['.gitignore']
+  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_dependency 'ffi-rzmq', '~> 2.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-reporters'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: zy
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alfa
+platform: ruby
+authors:
+- Ethan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-rzmq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.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: minitest
+  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: minitest-reporters
+  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: zy
+email:
+- ethan@unth
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile.rb
+- lib/zy.rb
+- lib/zy/natra.rb
+- lib/zy/reply.rb
+- lib/zy/request.rb
+- lib/zy/server.rb
+- lib/zy/version.rb
+- test/basic_interaction_test.rb
+- test/helper.rb
+- zy.gemspec
+homepage: ''
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: zy
+test_files:
+- test/basic_interaction_test.rb
+- test/helper.rb
+has_rdoc: