zss 0.0.2 → 0.0.3

data/lib/zss/socket.rb

@@ -1,4 +1,5 @@
 require 'ffi-rzmq'
+require 'timeout'
 
 module ZSS
   class Socket
@@ -39,30 +40,32 @@ module ZSS
     private
 
     def context
-      context = ZMQ::Context.create(1)
-      fail Socket::Error, 'failed to create context' unless context
-      yield context
+      ctx = ZMQ::Context.create(1)
+      fail Socket::Error, 'failed to create create_context' unless ctx
+      yield ctx
     ensure
-      check!(context.terminate) if context
+      check!(ctx.terminate) if ctx
     end
 
-    def socket context
+    def socket(context)
       socket = context.socket ZMQ::DEALER
       fail Socket::Error, 'failed to create socket' unless socket
       socket.identity = "#{identity}##{SecureRandom.uuid}"
       socket.setsockopt(ZMQ::LINGER, 0)
-      socket.bind(socket_address)
+      socket.connect(socket_address)
       yield socket
     ensure
-      check! socket.close if socket
+      check!(socket.close) if socket
     end
 
     def send_message socket, message
       frames = message.to_frames
-      first   = frames.shift
+
+      # if it's a reply should send identity
+      frames.shift if message.req?
       last   = frames.pop
       frames.each { |f| check! socket.send_string f.to_s, ZMQ::SNDMORE }
-      check! socket.send_string last
+      check! socket.send_string last.to_s
     end
 
     def receive_message socket

data/lib/zss/version.rb

@@ -1,3 +1,3 @@
 module ZSS
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/integration/client_spec.rb

@@ -16,7 +16,8 @@ describe ZSS::Client do
   end
 
   after :each do
-    @broker.terminate if @broker
+    return unless @broker
+    @broker.join
     @broker = nil
   end
 
@@ -25,7 +26,7 @@ describe ZSS::Client do
   end
 
   it('returns service response') do
-    @broker = run_broker(broker_frontend) do |msg|
+    @broker = run_broker_for_client(broker_frontend) do |msg|
       expect(msg.payload).to eq("ping")
       msg.status = 200
       msg.payload = "PONG"

data/spec/integration/service_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'spec_broker_helper'
+require 'em-zeromq'
+require 'zss/service'
+
+describe ZSS::Service do
+  include BrokerHelper
+
+  class DummyService
+    def ping payload, headers
+      headers[:took] = "0s"
+      return "PONG"
+    end
+  end
+
+  let(:broker_backend) { "ipc://socket_test" }
+
+  let(:config) do
+    Hashie::Mash.new(
+      backend: broker_backend,
+      heartbeat:  2000
+    )
+  end
+
+  let(:address) { ZSS::Message::Address.new(sid: "pong", verb: "ping") }
+
+  let(:message) { ZSS::Message.new(address: address, payload: "PING") }
+
+  subject { described_class.new(:pong, config) }
+
+  it('handles request') do
+    EM.run do
+      run_broker_for_service(broker_backend, message) do |msg|
+        expect(msg.payload).to eq("PONG")
+        expect(msg.status).to eq(200)
+        expect(msg.headers).to eq({ "took" => "0s" })
+        subject.stop
+        EM.stop
+      end
+
+      service = DummyService.new
+      subject.add_route(service, :ping)
+      subject.run
+    end
+
+  end
+
+end

data/spec/integration/socket_spec.rb

@@ -14,7 +14,8 @@ describe ZSS::Socket do
   let(:message) { ZSS::Message.new(address: address, payload: "PING") }
 
   after :each do
-    @broker.terminate if @broker
+    return unless @broker
+    @broker.join
     @broker = nil
   end
 
@@ -23,7 +24,7 @@ describe ZSS::Socket do
     subject { ZSS::Socket.new(config) }
 
     it('returns service response') do
-      @broker = run_broker(broker_frontend) do |msg|
+      @broker = run_broker_for_client(broker_frontend) do |msg|
         msg.status = 200
         msg.payload = "PONG"
       end

data/spec/spec_broker_helper.rb

@@ -1,11 +1,11 @@
-require 'ffi-rzmq'
+require 'em-zeromq'
 require 'msgpack'
 
 module BrokerHelper
 
   LOG_BROKER_INFO = false
 
-  def run_broker(endpoint)
+  def run_broker_for_client(endpoint)
 
     Thread.new do
       puts "broker running" if LOG_BROKER_INFO
@@ -16,7 +16,7 @@ module BrokerHelper
           context = ZMQ::Context.create
           socket = context.socket ZMQ::ROUTER
           socket.setsockopt(ZMQ::LINGER, 0)
-          socket.connect(endpoint)
+          socket.bind(endpoint)
           puts "broker connected" if LOG_BROKER_INFO
 
           socket.recv_strings(frames = [])
@@ -31,11 +31,8 @@ module BrokerHelper
             frames = msg.to_frames
             socket.send_strings(frames)
 
-            puts "broker sending #{frames}" if LOG_BROKER_INFO
+            puts "broker reply #{frames}" if LOG_BROKER_INFO
           end
-
-          Thread.stop
-
         rescue => e
           puts "WTF => #{e}"
         ensure
@@ -49,4 +46,55 @@ module BrokerHelper
     end
 
   end
+
+  def run_broker_for_service(endpoint, send_message = nil)
+    context = EM::ZeroMQ::Context.new(1)
+    socket = context.socket(ZMQ::ROUTER)
+    socket.setsockopt(ZMQ::LINGER, 0)
+    socket.on(:message) do |*frames|
+      frames = get_frames_and_close_message(frames)
+      puts "broker received #{frames}" if LOG_BROKER_INFO
+      service_id = frames.shift if frames.length == 9
+      msg = ZSS::Message.parse(frames)
+
+      if msg.address.sid == 'SMI'
+        handle_smi_verbs(socket, msg, send_message)
+      else
+        puts "check service response" if LOG_BROKER_INFO
+        yield(msg) if block_given?
+      end
+
+    end
+
+    socket.bind(endpoint)
+  end
+
+  private
+
+  def handle_smi_verbs(socket, msg, send_message)
+
+    if msg.address.verb == 'UP'
+      msg.status = 200
+      msg.type = ZSS::Message::Type::REP
+      puts "broker reply to UP" if LOG_BROKER_INFO
+      socket.send_msg(*msg.to_frames)
+
+      if send_message
+        send_message.identity = msg.identity
+        puts "broker sending emulated client request" if LOG_BROKER_INFO
+        # emulate client request
+        socket.send_msg(*send_message.to_frames)
+      end
+
+    end
+  end
+
+  def get_frames_and_close_message(frames)
+    frames.map do |frame|
+      out_frame = frame.copy_out_string
+      frame.close
+      out_frame
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -15,5 +15,14 @@ $:.push '.'
 require 'rspec'
 require 'pry'
 require 'zss'
+require 'timeout'
 
 Dir['spec/support/**/*.rb'].each &method(:require)
+
+RSpec.configure do |c|
+  c.around(:each) do |example|
+    Timeout::timeout(2) {
+      example.run
+    }
+  end
+end

data/spec/unit/client_spec.rb

@@ -52,7 +52,7 @@ describe ZSS::Client do
             timeout: 1000
           )
         )
-      subject.call(:ping)
+      subject.call(:ping, nil)
     end
 
     context('on success') do

data/spec/unit/error_spec.rb

@@ -6,22 +6,35 @@ describe ZSS::Error do
     Hashie::Mash.new(userMessage: "user info", developerMessage: "dev info")
   end
 
-  subject do
-    described_class.new(500, response)
-  end
+  describe('#ctor') do
 
-  it('returns a fullfilled error.message') do
-    expect(subject.code).to eq(500)
-    expect(subject.developer_message).to eq("dev info")
-    expect(subject.user_message).to eq("user info")
-  end
+    subject do
+      described_class.new(500, response)
+    end
+
+    it('returns a fullfilled error.message') do
+      expect(subject.code).to eq(500)
+      expect(subject.developer_message).to eq("dev info")
+      expect(subject.user_message).to eq("user info")
+    end
+
+    it('returns error with dev info as error.message') do
+      expect(subject.message).to eq("dev info")
+    end
+
+    it('returns error with stacktrace') do
+      expect(subject.backtrace).not_to be_nil
+    end
 
-  it('returns error with dev info as error.message') do
-    expect(subject.message).to eq("dev info")
   end
 
-  it('returns error with stacktrace') do
-    expect(subject.backtrace).not_to be_nil
+  describe('.[]') do
+
+    it('returns the error') do
+      result = described_class[500]
+      expect(result.code).to eq(500)
+    end
+
   end
 
 end

data/spec/unit/message_spec.rb

@@ -183,4 +183,18 @@ describe ZSS::Message do
 
   end
 
+  describe('.req?') do
+
+    it('returns true on request message') do
+      message.type = ZSS::Message::Type::REQ
+      expect(message.req?).to eq(true)
+    end
+
+    it('returns false on response message') do
+      message.type = ZSS::Message::Type::REP
+      expect(message.req?).to eq(false)
+    end
+
+  end
+
 end

data/spec/unit/router_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'zss/router'
+
+describe ZSS::Router do
+
+  class Dummy
+
+    def print(payload); end
+
+    def print_with_headers(payload, header); end
+
+  end
+
+  subject { described_class.new }
+
+  let(:context_object) { Dummy.new }
+
+  describe('#ctor') do
+
+  end
+
+  describe('#add_route') do
+
+    it('register route successfully') do
+      subject.add(context_object, "print", :print)
+    end
+
+    it('register route successfully without handler') do
+      subject.add(context_object, :print)
+    end
+
+
+    context('on error') do
+
+      it('raises a Error on invalid context') do
+        expect { subject.add(nil, :route) }.
+          to raise_exception
+      end
+
+      it('raises a Error on invalid route') do
+        expect { subject.add(context_object, nil) }.
+          to raise_exception
+      end
+
+      it('raises a Error on invalid handler') do
+        expect { subject.add(context_object, :route) }.
+          to raise_exception
+      end
+
+    end
+
+  end
+
+  describe('#get_route') do
+
+    before(:each) do
+      subject.add(context_object, "print", :print)
+      subject.add(context_object, "print_with_headers", :print_with_headers)
+    end
+
+    context('on error') do
+
+      it('raises a ZSS::Error on invalid verb') do
+        expect { subject.get("route") }.
+          to raise_exception(ZSS::Error)
+      end
+
+    end
+
+    context('on success') do
+
+      it('returns route handler') do
+        expect(subject.get("print")).to be_truthy
+      end
+
+    end
+
+    context('call route handler') do
+
+      it('successfully call with payload') do
+        expect(context_object).to receive(:print).with("print")
+        subject.get("print").call("print")
+      end
+
+      it('successfully call with payload and headers') do
+        expect(context_object).to receive(:print_with_headers)
+          .with("print_with_headers", { header: "x" })
+
+        subject.get("print_with_headers")
+          .call("print_with_headers", { header: "x" })
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/service_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+require 'zss'
+require 'zss/service'
+require 'em-zeromq'
+
+describe ZSS::Service do
+
+  let(:socket_address) { "ipc://socket_spec" }
+
+  let :config do
+    Hashie::Mash.new(
+      backend: socket_address,
+      heartbeat: 60000
+    )
+  end
+
+  class DummyService
+    def ping payload, headers
+      headers[:took] = "0s"
+      return "PONG"
+    end
+
+    def ping_fail payload, headers
+      fail 'should raise exception'
+    end
+  end
+
+  def done
+    subject.stop
+    EM.stop
+  end
+
+  let(:context) { double('EM::ZeroMQ::Context').as_null_object }
+  let(:socket) { double('EM::ZMQ::Socket').as_null_object }
+
+  before :each do
+    allow(EM::ZeroMQ::Context).to receive(:new) { context }
+    allow(context).to receive(:socket) { socket }
+    allow(SecureRandom).to receive(:uuid) { "uuid" }
+    config.heartbeat = 60000
+  end
+
+  after :each do
+    EM.stop if EM.reactor_running?
+  end
+
+  subject do
+    described_class.new(:pong, config)
+  end
+
+  describe('#ctor') do
+
+    it('returns a service with default config') do
+      subject = described_class.new(:pong)
+      expect(subject.sid).to eq("PONG")
+      expect(subject.backend).to eq(ZSS::Configuration.default.backend)
+      expect(subject.heartbeat).to eq(1000)
+    end
+
+    it('returns a service with config') do
+      config = Hashie::Mash.new(
+        backend: "socket",
+        heartbeat:  2000
+      )
+      subject = described_class.new(:pong, config)
+      expect(subject.sid).to eq("PONG")
+      expect(subject.backend).to eq("socket")
+      expect(subject.heartbeat).to eq(2000)
+    end
+
+    it('raises an error on invalid sid') do
+
+      expect do
+        described_class.new(nil, nil)
+      end.to raise_exception(ZSS::Error) do |error|
+          expect(error.code).to eq(500)
+      end
+
+    end
+
+  end
+
+  describe('#run') do
+
+    context('on error') do
+
+      it('raises RuntimeError on invalid context') do
+        expect(EM::ZeroMQ::Context).to receive(:new) { nil }
+        expect { subject.run }.to raise_exception(RuntimeError)
+      end
+
+      it('raises RuntimeError on invalid socket') do
+        expect(context).to receive(:socket) { nil }
+        expect { subject.run }.to raise_exception(RuntimeError)
+      end
+
+    end
+
+    context('open ZMQ Socket') do
+
+      it('with dealer type') do
+        expect(context).to receive(:socket).with(ZMQ::DEALER) do
+          done
+          socket
+        end
+        subject.run
+      end
+
+      it('with identity set') do
+        expect(socket).to receive(:identity=).with("pong#uuid") { done }
+        subject.run
+      end
+
+      it('with linger set to 0') do
+        expect(socket).to receive(:setsockopt).with(ZMQ::LINGER, 0) { done }
+        subject.run
+      end
+
+      it('connect to socket address') do
+        expect(socket).to receive(:connect).with(socket_address) { done }
+        subject.run
+      end
+
+    end
+
+    it('register service on broker') do
+      expect(socket).to receive(:send_msg) do |*frames|
+        message = ZSS::Message.parse(frames)
+        expect(message.address.sid).to eq('SMI')
+        expect(message.address.verb).to eq('UP')
+        expect(message.payload).to eq('PONG')
+        done
+        true
+      end
+
+      subject.run
+    end
+
+    context('handling requests') do
+
+      let(:address) { ZSS::Message::Address.new(sid: "PONG", verb: "PING") }
+
+      let(:message) { ZSS::Message.new(address: address, payload: "PING") }
+
+      let :message_parts do
+        message.to_frames.map { |f| ZMQ::Message.new(f) }
+      end
+
+      it('returns payload and headers') do
+        service = DummyService.new
+        subject.add_route(service, :ping)
+
+        EM.run do
+          allow(socket).to receive(:on) do |event, &block|
+            EM.add_timer { block.call *message_parts }
+          end
+
+          subject.run
+
+          expect(socket).to receive(:send_msg) do |*frames|
+            message = ZSS::Message.parse(frames)
+
+            expect(message.type).to eq(ZSS::Message::Type::REP)
+            expect(message.status).to eq(200)
+            expect(message.headers).to eq({ "took" => "0s" })
+
+            done
+
+            true
+          end
+        end
+
+      end
+
+      context('on error') do
+
+        it('returns 404 on invalid sid') do
+          message.address.sid = "something"
+
+          EM.run do
+            allow(socket).to receive(:on) do |event, &block|
+              EM.add_timer { block.call *message_parts }
+            end
+
+            subject.run
+
+            expect(socket).to receive(:send_msg) do |*frames|
+              message = ZSS::Message.parse(frames)
+
+              expect(message.type).to eq(ZSS::Message::Type::REP)
+              expect(message.status).to eq(404)
+
+              done
+
+              true
+            end
+          end
+
+        end
+
+        it('returns 404 on invalid verb') do
+
+          message.address.verb = "something"
+
+          EM.run do
+            allow(socket).to receive(:on) do |event, &block|
+              EM.add_timer { block.call *message_parts }
+            end
+
+            subject.run
+
+            expect(socket).to receive(:send_msg) do |*frames|
+              message = ZSS::Message.parse(frames)
+
+              expect(message.type).to eq(ZSS::Message::Type::REP)
+              expect(message.status).to eq(404)
+
+              done
+
+              true
+            end
+          end
+
+        end
+
+        it('returns 500 when an error occurred while handling request') do
+
+          service = DummyService.new
+          subject.add_route(service, "PING/FAIL", :ping_fail)
+          message.address.verb = "PING/FAIL"
+
+          EM.run do
+            allow(socket).to receive(:on) do |event, &block|
+              EM.add_timer { block.call *message_parts }
+            end
+
+            subject.run
+
+            expect(socket).to receive(:send_msg) do |*frames|
+              message = ZSS::Message.parse(frames)
+
+              expect(message.type).to eq(ZSS::Message::Type::REP)
+              expect(message.status).to eq(500)
+
+              done
+
+              true
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+    it('sends heartbeat message') do
+      config.heartbeat = 500
+      subject = described_class.new(:pong, config)
+
+      EM.run do
+
+        subject.run
+
+        expect(socket).to receive(:send_msg) do |*frames|
+          message = ZSS::Message.parse(frames)
+
+          expect(message.type).to eq(ZSS::Message::Type::REQ)
+          expect(message.address.sid).to eq('SMI')
+          expect(message.address.verb).to eq('HEARTBEAT')
+          expect(message.payload).to eq('PONG')
+
+          done
+
+          true
+        end
+      end
+    end
+
+  end
+
+  describe('#stop') do
+
+    it('disconnects the socket') do
+      EM.run do
+        subject.run
+
+        expect(socket).to receive(:disconnect) { done }
+
+        subject.stop
+      end
+    end
+
+    it('unregister service on broker') do
+      EM.run do
+
+        subject.run
+
+        expect(socket).to receive(:send_msg) do |*frames|
+          message = ZSS::Message.parse(frames)
+          expect(message.address.sid).to eq('SMI')
+          expect(message.address.verb).to eq('DOWN')
+          expect(message.payload).to eq('PONG')
+          done
+          1
+        end
+
+        subject.stop
+      end
+    end
+
+  end
+
+end