krakow 0.1.2 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v0.2.0
+* Fix the rest of the namespacing issues
+* Start adding some tests
+* Use better exception types (NotImplementedError instead of NoMethodError)
+* Be smart about responses within connections
+* Add snappy support
+* Add deflate support
+* Add TLS support
+* Prevent division by zero in distribution
+* Add query methods to lazy helper (`attribute_name`?)
+
 ## v0.1.2
 * Include backoff support
 * Remove `method_missing` magic

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'minitest'
+
 gemspec

data/Gemfile.lock

@@ -1,10 +1,12 @@
 PATH
   remote: .
   specs:
-    krakow (0.1.1)
+    krakow (0.1.3)
       celluloid-io
+      digest-crc
       http
       multi_json
+      snappy
 
 GEM
   remote: https://rubygems.org/
@@ -14,11 +16,14 @@ GEM
     celluloid-io (0.15.0)
       celluloid (>= 0.15.0)
       nio4r (>= 0.5.0)
+    digest-crc (0.4.0)
     http (0.5.0)
       http_parser.rb
     http_parser.rb (0.6.0)
+    minitest (5.0.8)
     multi_json (1.8.4)
-    nio4r (0.5.0)
+    nio4r (1.0.0)
+    snappy (0.0.10)
     timers (1.1.0)
 
 PLATFORMS
@@ -26,3 +31,4 @@ PLATFORMS
 
 DEPENDENCIES
   krakow!
+  minitest

data/README.md

@@ -124,6 +124,51 @@ consumer = Krakow::Consumer.new(
 )
 ```
 
+### I need TLS!
+
+OK!
+
+```ruby
+consumer = Krakow::Consumer.new(
+  :nsqlookupd => 'http://HOST:PORT',
+  :topic => 'target',
+  :channel => 'ship',
+  :connection_features => {
+    :tls_v1 => true
+  }
+)
+```
+
+### I need Snappy compression!
+
+OK!
+
+```ruby
+consumer = Krakow::Consumer.new(
+  :nsqlookupd => 'http://HOST:PORT',
+  :topic => 'target',
+  :channel => 'ship',
+  :connection_features => {
+    :snappy => true
+  }
+)
+```
+
+### I need Deflate compression!
+
+OK!
+
+```ruby
+consumer = Krakow::Consumer.new(
+  :nsqlookupd => 'http://HOST:PORT',
+  :topic => 'target',
+  :channel => 'ship',
+  :connection_features => {
+    :deflate => true
+  }
+)
+```
+
 ### It doesn't work
 
 Create an issue on the github repository.

data/krakow.gemspec

@@ -12,5 +12,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'celluloid-io'
   s.add_dependency 'http'
   s.add_dependency 'multi_json'
+  s.add_dependency 'snappy'
+  s.add_dependency 'digest-crc'
   s.files = Dir['**/*']
 end

data/lib/krakow/command/identify.rb

@@ -34,6 +34,7 @@ module Krakow
         def error
           %w(E_INVALID E_BAD_BODY)
         end
+
       end
 
     end

data/lib/krakow/command.rb

@@ -13,6 +13,20 @@ module Krakow
         []
       end
 
+      # message:: Krakow::Message
+      # Returns type of response expected (:none, :error_only, :required)
+      def response_for(message)
+        if(message.class.ok.empty?)
+          if(message.class.error.empty?)
+            :none
+          else
+            :error_only
+          end
+        else
+          :required
+        end
+      end
+
     end
 
     attr_accessor :response
@@ -23,8 +37,8 @@ module Krakow
     end
 
     # Convert to line output
-    def to_line
-      raise NoMethodError.new 'No line conversion method defined!'
+    def to_line(*args)
+      raise NotImplementedError.new 'No line conversion method defined!'
     end
 
     def ok?(response)

data/lib/krakow/connection.rb

@@ -1,3 +1,4 @@
+require 'krakow/version'
 require 'celluloid/io'
 require 'celluloid/autostart'
 
@@ -7,18 +8,42 @@ module Krakow
     include Utils::Lazy
     include Celluloid::IO
 
+    FEATURES = [
+      :max_rdy_count,
+      :max_msg_timeout,
+      :msg_timeout,
+      :tls_v1,
+      :deflate,
+      :deflate_level,
+      :max_deflate_level,
+      :snappy,
+      :sample_rate
+    ]
+    EXCLUSIVE_FEATURES = [[:snappy, :deflate]]
+    ENABLEABLE_FEATURES = [:tls_v1, :snappy, :deflate]
+
     finalizer :goodbye_my_love!
 
-    attr_reader :socket
+    attr_reader :socket, :endpoint_settings
 
     def initialize(args={})
       super
       required! :host, :port
-      optional :version, :queue, :callback, :responses
+      optional(
+        :version, :queue, :callback, :responses, :notifier,
+        :features, :response_wait, :error_wait, :enforce_features
+      )
       arguments[:queue] ||= Queue.new
       arguments[:responses] ||= Queue.new
       arguments[:version] ||= 'v2'
+      arguments[:features] ||= {}
+      arguments[:response_wait] ||= 1
+      arguments[:error_wait] ||= 0.4
+      if(arguments[:enforce_features].nil?)
+        arguments[:enforce_features] = true
+      end
       @socket = TCPSocket.new(host, port)
+      @endpoint_settings = {}
     end
 
     def to_s
@@ -29,24 +54,44 @@ module Krakow
     def init!
       debug 'Initializing connection'
       socket.write version.rjust(4).upcase
+      identify_and_negotiate
       async.process_to_queue!
       info 'Connection initialized'
     end
 
     # message:: Command instance to send
     # Send the message
+    # TODO: Do we want to validate Command instance and abort if
+    # response is already set?
     def transmit(message)
       output = message.to_line
       debug ">>> #{output}"
       socket.write output
-      unless(responses.empty?)
-        response = responses.pop
-        message.response = response
-        if(message.error?(response))
-          res = Error::BadResponse.new "Message transmission failed #{message}"
-          res.result = response
-          abort res
+      response_wait = wait_time_for(message)
+      responses.clear if response_wait
+      if(response_wait)
+        response = nil
+        (response_wait / 0.1).to_i.times do |i|
+          response = responses.pop unless responses.empty?
+          break if response
+          debug "Response wait sleep for 0.1 seconds (#{i+1} time)"
+          sleep(0.1)
+        end
+        if(response)
+          message.response = response
+          if(message.error?(response))
+            res = Error::BadResponse.new "Message transmission failed #{message}"
+            res.result = response
+            abort res
+          end
+          response
+        else
+          unless(Command.response_for(message) == :error_only)
+            abort Error::BadResponse::NoResponse.new "No response provided for message #{message}"
+          end
         end
+      else
+        true
       end
     end
 
@@ -96,6 +141,7 @@ module Krakow
         if(message)
           debug "Adding message to queue #{message}"
           queue << message
+          notifier.signal(message) if notifier
         end
       end
     end
@@ -122,5 +168,77 @@ module Krakow
         end
       end
     end
+
+    def wait_time_for(message)
+      case Command.response_for(message)
+      when :required
+        response_wait
+      when :error_only
+        error_wait
+      end
+    end
+
+    def identify_defaults
+      unless(@identify_defaults)
+        @identify_defaults = {
+          :short_id => Socket.gethostname,
+          :long_id => Socket.gethostbyname(Socket.gethostname).flatten.compact.first,
+          :user_agent => "krakow/#{Krakow::VERSION}",
+          :feature_negotiation => true
+        }
+      end
+      @identify_defaults
+    end
+
+    def identify_and_negotiate
+      expected_features = identify_defaults.merge(features)
+      ident = Command::Identify.new(
+        expected_features
+      )
+      socket.write(ident.to_line)
+      response = receive
+      if(expected_features[:feature_negotiation])
+        begin
+          @endpoint_settings = MultiJson.load(response.content, :symbolize_keys => true)
+          info "Connection settings: #{endpoint_settings.inspect}"
+          # Enable things we need to enable
+          ENABLEABLE_FEATURES.each do |key|
+            if(endpoint_settings[key])
+              send(key)
+            elsif(enforce_features && expected_features[key])
+              abort Error::ConnectionFeatureFailure.new("Failed to enable #{key} feature on connection!")
+            end
+          end
+        rescue MultiJson::LoadError => e
+          error "Failed to parse response from Identify request: #{e} - #{response}"
+          abort e
+        end
+      else
+        @endpoint_settings = {}
+      end
+      true
+    end
+
+    def snappy
+      info 'Loading support for snappy compression and converting connection'
+      @socket = ConnectionFeatures::SnappyFrames::Io.new(socket)
+      response = receive
+      info "Snappy connection conversion complete. Response: #{response.inspect}"
+    end
+
+    def deflate
+      debug 'Loading support for deflate compression and converting connection'
+      @socket = ConnectionFeatures::Deflate::Io.new(socket)
+      response = receive
+      info "Deflate connection conversion complete. Response: #{response.inspect}"
+    end
+
+    def tls_v1
+      info 'Enabling TLS for connection'
+      @socket = ConnectionFeatures::Ssl::Io.new(socket)
+      response = receive
+      info "TLS enable complete. Response: #{response.inspect}"
+    end
+
   end
 end

data/lib/krakow/connection_features/deflate.rb

@@ -0,0 +1,57 @@
+require 'zlib'
+
+module Krakow
+  module ConnectionFeatures
+    module Deflate
+      class Io
+
+        attr_reader :io, :buffer, :headers, :inflator, :deflator
+
+        def initialize(io)
+          @io = io
+          @buffer = ''
+          @inflator = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          @deflator = Zlib::Deflate.new(nil, -Zlib::MAX_WBITS)
+        end
+
+        # Proxy to underlying socket
+        def method_missing(*args)
+          io.__send__(*args)
+        end
+
+        def recv(n)
+          until(buffer.length >= n)
+            read_stream
+            sleep(0.1) unless buffer.length >= n
+          end
+          buffer.slice!(0, n)
+        end
+        alias_method :read, :recv
+
+        def read_stream
+          str = io.read
+          unless(str.empty?)
+            buffer << inflator.inflate(str)
+          end
+        end
+
+        def write(string)
+          unless(string.empty?)
+            output = deflator.deflate(string)
+            output << deflator.flush
+            io.write(output)
+          else
+            0
+          end
+        end
+
+        def close(*args)
+          super
+          deflator.deflate(nil, Zlib::FINISH)
+          deflator.close
+        end
+
+      end
+    end
+  end
+end

data/lib/krakow/connection_features/snappy_frames.rb

@@ -0,0 +1,93 @@
+require 'snappy'
+require 'digest/crc'
+
+# TODO: Add support for max size + chunks
+# TODO: Include support for remaining types
+module Krakow
+  module ConnectionFeatures
+    module SnappyFrames
+      class Io
+
+        IDENTIFIER = "\x73\x4e\x61\x50\x70\x59".force_encoding('ASCII-8BIT')
+        ident_size = [IDENTIFIER.size].pack('L<')
+        ident_size.slice!(-1,1)
+        IDENTIFIER_SIZE = ident_size
+
+        CHUNK_TYPE = {
+          "\xff".force_encoding('ASCII-8BIT') => :identifier,
+          "\x00".force_encoding('ASCII-8BIT') => :compressed,
+          "\x01".force_encoding('ASCII-8BIT') => :uncompressed
+        }
+
+        attr_reader :io, :buffer
+
+        def initialize(io)
+          @io = io
+          @snappy_write_ident = false
+          @buffer = ''
+        end
+
+        # Proxy to underlying socket
+        def method_missing(*args)
+          io.__send__(*args)
+        end
+
+        def checksum_mask(checksum)
+          (((checksum >> 15) | (checksum << 17)) + 0xa282ead8) & 0xffffffff
+        end
+
+        def recv(n)
+          read_stream unless buffer.size >= n
+          result = buffer.slice!(0,n)
+          result.empty? ? nil : result
+        end
+        alias_method :read, :recv
+
+        def read_stream
+          header = io.recv(4)
+          ident = CHUNK_TYPE[header.slice!(0)]
+          size = (header << CHUNK_TYPE.key(:compressed)).unpack('L<').first
+          content = io.recv(size)
+          case ident
+          when :identifier
+            unless(content == IDENTIFIER)
+              raise "Invalid stream identification encountered (content: #{content.inspect})"
+            end
+            read_stream
+          when :compressed
+            checksum = content.slice!(0, 4).unpack('L<').first
+            deflated = Snappy.inflate(content)
+            digest = Digest::CRC32c.new
+            digest << deflated
+            unless(checksum == checksum_mask(digest.checksum))
+              raise 'Checksum mismatch!'
+            end
+            buffer << deflated
+          when :uncompressed
+            buffer << content
+          end
+        end
+
+        def write(string)
+          unless(@snappy_writer_ident)
+            send_snappy_identifier
+          end
+          digest = Digest::CRC32c.new
+          digest << string
+          content = Snappy.deflate(string)
+          size = content.length + 4
+          size = [size].pack('L<')
+          size.slice!(-1,1)
+          checksum = [checksum_mask(digest.checksum)].pack('L<')
+          output = [CHUNK_TYPE.key(:compressed), size, checksum, content].pack('a*a*a*a*')
+          io.write output
+        end
+
+        def send_snappy_identifier
+          io.write [CHUNK_TYPE.key(:identifier), IDENTIFIER_SIZE, IDENTIFIER].pack('a*a*a*')
+        end
+
+      end
+    end
+  end
+end

data/lib/krakow/connection_features/ssl.rb

@@ -0,0 +1,33 @@
+module Krakow
+  module ConnectionFeatures
+    module Ssl
+      class Io
+
+        attr_reader :_socket
+
+        def initialize(io, args={})
+          ssl_socket_arguments = [io]
+          if(args[:ssl_context])
+            # ssl_socket_arguments << SSLContext.new
+          end
+          @_socket = Celluloid::IO::SSLSocket.new(*ssl_socket_arguments)
+          _socket.sync = true
+          _socket.connect
+        end
+
+        def method_missing(*args)
+          _socket.send(*args)
+        end
+
+        def recv(len)
+          str = readpartial(len)
+          if(len > str.length)
+            str << sysread(len - str.length)
+          end
+          str
+        end
+
+      end
+    end
+  end
+end

data/lib/krakow/connection_features.rb

@@ -0,0 +1,9 @@
+require 'krakow'
+
+module Krakow
+  module ConnectionFeatures
+    autoload :SnappyFrames, 'krakow/connection_features/snappy_frames'
+    autoload :Deflate, 'krakow/connection_features/deflate'
+    autoload :Ssl, 'krakow/connection_features/ssl'
+  end
+end

data/lib/krakow/consumer.rb

@@ -12,9 +12,10 @@ module Krakow
     def initialize(args={})
       super
       required! :topic, :channel
-      optional :host, :port, :nslookupd, :max_in_flight, :backoff_interval, :discovery_interval
+      optional :host, :port, :nslookupd, :max_in_flight, :backoff_interval, :discovery_interval, :notifier, :connection_features
       arguments[:max_in_flight] ||= 1
       arguments[:discovery_interval] ||= 30
+      arguments[:connection_features] ||= {}
       @connections = {}
       @distribution = Distribution::Default.new(
         :max_in_flight => max_in_flight,
@@ -24,8 +25,8 @@ module Krakow
       if(nslookupd)
         debug "Connections will be established via lookup #{nslookupd.inspect}"
         @discovery = Discovery.new(:nslookupd => nslookupd)
-        every(discovery_interval){ init! }
         init!
+        every(discovery_interval){ init! }
       elsif(host && port)
         debug "Connection will be established via direct connection #{host}:#{port}"
         connection = build_connection(host, port, queue)
@@ -33,10 +34,10 @@ module Krakow
           info "Registered new connection #{connection}"
           distribution.redistribute!
         else
-          abort ConnectionFailure.new("Failed to establish subscription at provided end point (#{host}:#{port}")
+          abort Error::ConnectionFailure.new("Failed to establish subscription at provided end point (#{host}:#{port}")
         end
       else
-        abort ConfigurationError.new('No connection information provided!')
+        abort Error::ConfigurationError.new('No connection information provided!')
       end
     end
 
@@ -62,6 +63,8 @@ module Krakow
         :host => host,
         :port => port,
         :queue => queue,
+        :notifier => notifier,
+        :features => connection_features,
         :callback => {
           :actor => current_actor,
           :method => :process_message
@@ -135,23 +138,30 @@ module Krakow
       distribution.redistribute!
     end
 
-    # message_id:: Message ID
+    # message_id:: Message ID (or message if you want to be lazy)
     # Confirm message has been processed
     def confirm(message_id)
-      distribution.in_flight_lookup(message_id) do |connection|
-        connection.transmit(Command::Fin.new(:message_id => message_id))
-        distribution.success(connection)
+      message_id = message_id.message_id if message_id.respond_to?(:message_id)
+      begin
+        distribution.in_flight_lookup(message_id) do |connection|
+          distribution.unregister_message(message_id)
+          connection.transmit(Command::Fin.new(:message_id => message_id))
+          distribution.success(connection)
+          update_ready!(connection)
+        end
+        true
+      rescue => e
+        abort e
       end
-      connection = distribution.unregister_message(message_id)
-      update_ready!(connection)
-      true
     end
 
     # message_id:: Message ID
     # timeout:: Requeue timeout (default is none)
     # Requeue message (processing failure)
     def requeue(message_id, timeout=0)
+      message_id = message_id.message_id if message_id.respond_to?(:message_id)
       distribution.in_flight_lookup(message_id) do |connection|
+        distribution.unregister_message(message_id)
         connection.transmit(
           Command::Req.new(
             :message_id => message_id,
@@ -159,9 +169,8 @@ module Krakow
           )
         )
         distribution.failure(connection)
+        update_ready!(connection)
       end
-      connection = distribution.unregister_message(message_id)
-      update_ready!(connection)
       true
     end
 

data/lib/krakow/distribution/default.rb

@@ -6,7 +6,7 @@ module Krakow
 
       # recalculate `ideal` and update RDY on connections
       def redistribute!
-        @ideal = max_in_flight / registry.size
+        @ideal = registry.size < 1 ? 0 : max_in_flight / registry.size
         debug "Distribution calculated ideal: #{ideal}"
         if(less_than_ideal?)
           registry.each do |connection, reg_info|

data/lib/krakow/distribution.rb

@@ -22,13 +22,13 @@ module Krakow
 
     # Reset flight distributions
     def redistribute!
-      raise NoMethodError.new 'Custom `#redistrubute!` method must be provided!'
+      raise NotImplementedError.new 'Custom `#redistrubute!` method must be provided!'
     end
 
     # connection:: Connection
     # Determine RDY value for given connection
     def calculate_ready!(connection)
-      raise NoMethodError.new 'Custom `#calculate_ready!` method must be provided!'
+      raise NotImplementedError.new 'Custom `#calculate_ready!` method must be provided!'
     end
 
     # message:: FrameType::Message or message ID string

data/lib/krakow/exceptions.rb

@@ -1,12 +1,15 @@
 module Krakow
   class Error < StandardError
 
+    class ConnectionFeatureFailure < Error; end
     class LookupFailed < Error; end
     class ConnectionFailure < Error; end
     class ConfigurationError < Error; end
 
     class BadResponse < Error
       attr_accessor :result
+      class NoResponse < BadResponse
+      end
     end
 
   end

data/lib/krakow/producer/http.rb

@@ -1,15 +1,20 @@
 require 'http'
 require 'uri'
+require 'ostruct'
 
 module Krakow
   class Producer
     class Http
 
+      class Response < OpenStruct
+      end
+
       include Utils::Lazy
 
       attr_reader :uri
 
       def initialize(args={})
+        super
         required! :endpoint, :topic
         @uri = URI.parse(endpoint)
       end
@@ -17,7 +22,13 @@ module Krakow
       def send_message(method, path, args={})
         build = uri.dup
         build.path = "/#{path}"
-        HTTP.send(method, build.to_s, args)
+        response = HTTP.send(method, build.to_s, args)
+        begin
+          response = MultiJson.load(response.response.body)
+        rescue MultiJson::LoadError
+          response = {'status_code' => response == 'OK' ? 200 : nil, 'status_txt' => response, 'data' => nil}
+        end
+        Response.new(response)
       end
 
       def write(*payload)
@@ -110,6 +121,10 @@ module Krakow
         send_message(:get, :ping)
       end
 
+      def info
+        send_message(:get, :info)
+      end
+
     end
   end
 end

data/lib/krakow/producer.rb

@@ -14,9 +14,10 @@ module Krakow
     def initialize(args={})
       super
       required! :host, :port, :topic
-      optional :connect_retries
+      optional :reconnect_retries, :reconnect_interval, :connection_features
       arguments[:reconnect_retries] ||= 10
       arguments[:reconnect_interval] = 5
+      arguments[:connection_features] ||= {}
       connect
     end
 
@@ -24,7 +25,11 @@ module Krakow
     def connect
       info "Establishing connection to: #{host}:#{port}"
       begin
-        @connection = Connection.new(:host => host, :port => port)
+        @connection = Connection.new(
+          :host => host,
+          :port => port,
+          :features => connection_features
+        )
         self.link connection
         connection.init!
         info "Connection established: #{connection}"
@@ -45,21 +50,9 @@ module Krakow
     # Process connection failure and attempt reconnection
     def connection_failure(*args)
       warn "Connection has failed to #{host}:#{port}"
-      retries = 0
-      begin
-        connect
-      rescue => e
-        retries += 1
-        warn "Connection retry #{retries}/#{reconnect_retries} failed. #{e.class}: #{e}"
-        if(retries < reconnect_retries)
-          sleep_interval = retries * reconnect_interval
-          debug "Sleeping for reconnect interval of #{sleep_interval} seconds"
-          sleep sleep_interval
-          retry
-        else
-          abort e
-        end
-      end
+      debug "Sleeping for reconnect interval of #{reconnect_interval} seconds"
+      sleep reconnect_interval
+      connect
     end
 
     def goodbye_my_love!
@@ -92,26 +85,10 @@ module Krakow
             )
           )
         end
-        read(:validate)
       else
         abort Error.new 'Remote connection is unavailable!'
       end
     end
 
-    # args:: Options (:validate)
-    # Read response from connection. If :validate is included an
-    # exception will be raised if `FrameType::Error` is received
-    def read(*args)
-      result = connection.responses.pop
-      debug "Read response: #{result}"
-      if(args.include?(:validate) && result.is_a?(FrameType::Error))
-        error = Error::BadResponse.new('Write failed')
-        error.result = result
-        abort error
-      else
-        result
-      end
-    end
-
   end
 end

data/lib/krakow/utils/lazy.rb

@@ -26,6 +26,11 @@ module Krakow
           define_singleton_method(key) do
             arguments[key]
           end
+          if(key.match(/\w$/))
+            define_singleton_method("#{key}?".to_sym) do
+              !!arguments[key]
+            end
+          end
         end
       end
 
@@ -40,6 +45,11 @@ module Krakow
           define_singleton_method(key) do
             arguments[key]
           end
+          if(key.match(/\w$/))
+            define_singleton_method("#{key}?".to_sym) do
+              !!arguments[key]
+            end
+          end
         end
       end
 

data/lib/krakow/version.rb

@@ -1,7 +1,5 @@
-require 'krakow'
-
 module Krakow
   class Version < Gem::Version
   end
-  VERSION = Version.new('0.1.2')
+  VERSION = Version.new('0.2.0')
 end

data/lib/krakow.rb

@@ -1,9 +1,11 @@
-autoload :Celluloid, 'celluloid'
+require 'celluloid/autostart'
+require 'multi_json'
 
 module Krakow
 
   autoload :Command, 'krakow/command'
   autoload :Connection, 'krakow/connection'
+  autoload :ConnectionFeatures, 'krakow/connection_features'
   autoload :Consumer, 'krakow/consumer'
   autoload :Discovery, 'krakow/discovery'
   autoload :Distribution, 'krakow/distribution'

data/test/spec.rb

@@ -0,0 +1,81 @@
+require 'krakow'
+require 'minitest/autorun'
+
+module Krakow
+  class Test
+    class << self
+
+      def method_missing(*args)
+        name = method = args.first.to_s
+        if(name.end_with?('?'))
+          name = name.tr('?', '')
+        end
+        val = ENV[name.upcase] || ENV[name]
+        if(method.end_with?('?'))
+          !!val
+        else
+          val
+        end
+      end
+
+      def _topic
+        'krakow-test'
+      end
+
+      def _scrub_topic!
+        _http_producer.delete_topic
+      end
+
+      def _http_producer
+        @http_producer ||= Krakow::Producer::Http.new(
+          :endpoint => 'http://127.0.0.1:4151',
+          :topic => _topic
+        )
+      end
+
+      def _producer(args={})
+        Krakow::Producer.new(
+          {
+            :host => Krakow::Test.nsq_producer_host || '127.0.0.1',
+            :port => Krakow::Test.nsq_producer_port || 4150,
+            :topic => 'krakow-test'
+          }.merge(args)
+        )
+      end
+
+      def _consumer(args={})
+        Krakow::Consumer.new(
+          {
+            :nslookupd => Krakow::Test.nsq_lookupd || 'http://127.0.0.1:4161',
+            :topic => 'krakow-test',
+            :channel => 'default',
+            :discovery_interval => 0.5,
+            :max_in_flight => 20
+          }.merge(args)
+        )
+      end
+
+    end
+  end
+end
+
+MiniTest::Spec.before do
+  Celluloid.boot
+  Krakow::Test._scrub_topic!
+  @consumer = Krakow::Test._consumer
+  @producer = Krakow::Test._producer
+end
+
+MiniTest::Spec.after do
+  @consumer.terminate if @consumer && @consumer.alive?
+  @producer.terminate if @producer && @producer.alive?
+  Krakow::Test._scrub_topic!
+end
+
+unless(Krakow::Test.debug?)
+  Celluloid.logger.level = 3
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), 'specs', '*.rb')).each do |path|
+  require File.expand_path(path)
+end

data/test/specs/consumer.rb

@@ -0,0 +1,49 @@
+describe Krakow do
+
+  describe Krakow::Consumer do
+
+    it 'should not have any connections' do
+      @consumer.connections.size.must_equal 0
+    end
+    it 'should have an empty queue' do
+      @consumer.queue.size.must_equal 0
+    end
+
+    describe 'with active producer' do
+
+      before do
+        @producer.write('msg1', 'msg2', 'msg3')
+        @inital_wait ||= sleep(0.8) # allow setup (topic creation, discovery, etc)
+      end
+
+      it 'should have one connection' do
+        @consumer.connections.size.must_equal 1
+      end
+      it 'should have three messages queued' do
+        @consumer.queue.size.must_equal 3
+      end
+      it 'should properly confirm messages' do
+        3.times do
+          msg = @consumer.queue.pop
+          @consumer.confirm(msg).must_equal true
+        end
+        sleep(0.5) # pause to let everything settle
+        @consumer.queue.must_be :empty?
+      end
+      it 'should properly requeue messages' do
+        2.times do
+          @consumer.confirm(@consumer.queue.pop)
+        end
+        @consumer.queue.size.must_equal 1
+        original_msg = @consumer.queue.pop
+        @consumer.queue.must_be :empty?
+        @consumer.requeue(original_msg).must_equal true
+        sleep(0.2)
+        @consumer.queue.size.must_equal 1
+        req_msg = @consumer.queue.pop
+        req_msg.message_id.must_equal original_msg.message_id
+      end
+
+    end
+  end
+end

data/test/specs/http_producer.rb

@@ -0,0 +1,123 @@
+describe Krakow do
+
+  describe Krakow::Producer::Http do
+
+    before do
+      @http = Krakow::Test._http_producer
+    end
+
+    it 'should write single messages successfully' do
+      response = @http.write('msg')
+      Krakow::Command::Pub.ok.must_include response.status_txt
+    end
+    it 'should write multiple messages successfully' do
+      response = @http.write('msg1', 'msg2', 'msg3')
+      Krakow::Command::Mpub.ok.must_include response.status_txt
+    end
+    it 'should create topic' do
+      response = @http.create_topic
+      response.status_code.must_equal 200
+      response.status_txt.must_equal 'OK'
+    end
+    it 'should delete topic' do
+      c_response = @http.create_topic
+      c_response.status_code.must_equal 200
+      c_response.status_txt.must_equal 'OK'
+      d_response = @http.delete_topic
+      d_response.status_code.must_equal 200
+      d_response.status_txt.must_equal 'OK'
+    end
+    it 'should create channel' do
+      c_response = @http.create_topic
+      c_response.status_code.must_equal 200
+      c_response.status_txt.must_equal 'OK'
+      ch_response = @http.create_channel('fubar')
+      ch_response.status_code.must_equal 200
+      ch_response.status_txt.must_equal 'OK'
+    end
+    it 'should delete channel' do
+      c_response = @http.create_topic
+      c_response.status_code.must_equal 200
+      c_response.status_txt.must_equal 'OK'
+      ch_response = @http.create_channel('fubar')
+      ch_response.status_code.must_equal 200
+      ch_response.status_txt.must_equal 'OK'
+      dch_response = @http.delete_channel('fubar')
+      dch_response.status_code.must_equal 200
+      dch_response.status_txt.must_equal 'OK'
+    end
+    it 'should empty topic' do
+      @consumer.terminate
+      @http.write('msg1', 'msg2', 'msg3').status_code.must_equal 200
+      et_response = @http.empty_topic
+      et_response.status_code.must_equal 200
+      et_response.status_txt.must_equal 'OK'
+      @consumer = Krakow::Test._consumer
+      sleep(0.2)
+      @consumer.connections.wont_be :empty?
+      @consumer.queue.must_be :empty?
+    end
+    it 'should empty channel' do
+      @consumer.terminate
+      @http.write('msg0')
+      @http.pause_channel('chan2').status_code.must_equal 200
+      consumer1 = Krakow::Test._consumer(:channel => 'chan1')
+      consumer2 = Krakow::Test._consumer(:channel => 'chan2')
+      @http.write('msg1', 'msg2', 'msg3').status_code.must_equal 200
+      sleep(0.5)
+      consumer1.queue.size.must_equal 4
+      consumer2.queue.size.must_equal 0
+      @http.empty_channel('chan2').status_code.must_equal 200
+      @http.unpause_channel('chan2').status_code.must_equal 200
+      sleep(0.5)
+      consumer1.queue.size.must_equal 4
+      consumer2.queue.size.must_equal 0
+      consumer1.terminate
+      consumer2.terminate
+    end
+    it 'should pause channel' do
+      @consumer.terminate
+      @http.write('msg0')
+      @http.pause_channel('chan2').status_code.must_equal 200
+      consumer1 = Krakow::Test._consumer(:channel => 'chan1')
+      consumer2 = Krakow::Test._consumer(:channel => 'chan2')
+      @http.write('msg1', 'msg2', 'msg3').status_code.must_equal 200
+      sleep(0.5)
+      consumer1.queue.size.must_equal 4
+      consumer2.queue.size.must_equal 0
+      consumer1.terminate
+      consumer2.terminate
+    end
+    it 'should unpause channel' do
+      @consumer.terminate
+      @http.write('msg0')
+      @http.pause_channel('chan2').status_code.must_equal 200
+      consumer1 = Krakow::Test._consumer(:channel => 'chan1')
+      consumer2 = Krakow::Test._consumer(:channel => 'chan2')
+      @http.write('msg1', 'msg2', 'msg3').status_code.must_equal 200
+      sleep(0.5)
+      consumer1.queue.size.must_equal 4
+      consumer2.queue.size.must_equal 0
+      @http.unpause_channel('chan2').status_code.must_equal 200
+      sleep(0.5)
+      consumer2.queue.size.must_equal 4
+      consumer1.terminate
+      consumer2.terminate
+    end
+    it 'should return stats' do
+      stat = @http.stats
+      stat.status_code.must_equal 200
+      stat.data.must_be_kind_of Hash
+    end
+    it 'should ping' do
+      @http.ping.status_code.must_equal 200
+    end
+    it 'should fetch info' do
+      infos = @http.info
+      infos.status_code.must_equal 200
+      infos.data.must_be_kind_of Hash
+    end
+
+  end
+
+end

data/test/specs/producer.rb

@@ -0,0 +1,20 @@
+describe Krakow do
+
+  describe Krakow::Producer do
+
+    it 'should be connected' do
+      @producer.connected?.must_equal true
+    end
+    it 'should write single messages successfully' do
+      response = @producer.write('msg')
+      response.must_be_kind_of Krakow::FrameType::Response
+      Krakow::Command::Pub.ok.must_include response.content
+    end
+    it 'should write multiple messages successfully' do
+      response = @producer.write('msg1', 'msg2', 'msg3')
+      response.must_be_kind_of Krakow::FrameType::Response
+      Krakow::Command::Mpub.ok.must_include response.content
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: krakow
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-20 00:00:00.000000000 Z
+date: 2014-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -59,6 +59,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: snappy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: digest-crc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: NSQ ruby library
 email: code@chrisroberts.org
 executables: []
@@ -93,9 +125,18 @@ files:
 - lib/krakow/exceptions.rb
 - lib/krakow/utils.rb
 - lib/krakow/discovery.rb
+- lib/krakow/connection_features.rb
+- lib/krakow/connection_features/ssl.rb
+- lib/krakow/connection_features/snappy_frames.rb
+- lib/krakow/connection_features/deflate.rb
+- test/spec.rb
+- test/specs/consumer.rb
+- test/specs/producer.rb
+- test/specs/http_producer.rb
 - Gemfile
 - README.md
 - krakow.gemspec
+- krakow-0.2.0.gem
 - CHANGELOG.md
 - Gemfile.lock
 homepage: http://github.com/chrisroberts/krakow