krakow 0.0.1 → 0.1.0

data/CHANGELOG.md

@@ -1,2 +1,9 @@
-## v0.0.1
+	## v0.1.0
+	* Add logging support
+	* Include valid responses within commands
+	* Segregate responses from messages
+	* Manage connections in consumer (closed/reconnect)
+	* Add message distribution support
+
+	## v0.0.1
 	* Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    krakow (0.1.0)
+    krakow (0.0.1)
       celluloid-io
       http
       multi_json

data/README.md

@@ -12,7 +12,7 @@ producer = Krakow::Producer(
   :port => 'PORT',
   :topic => 'target'
 )
-producer.write('direct hit!')
+producer.write('KRAKOW!', 'KRAKOW!')
 ```
 
 ## Zargons
@@ -26,11 +26,74 @@ consumer = Krakow::Consumer(
   :channel => 'ship'
 )
 
-message = consumer.queue.pop
-# do stuff
-consumer.confirm(message.message_id)
+consumer.queue.size # => 2
+2.times do
+  msg = consumer.queue.pop
+  puts "Received: #{msg}"
+  consumer.confirm(msg.message_id)
+end
 ```
 
+## What is this?
+
+It's a Ruby library for NSQ[1] using Celluloid[2] under the hood.
+
+## Information and FAQ that I totally made up
+
+### Max in flight for consumers is 1, regardless of number of producers
+
+Yep, that's right. Just one lowly message at a time. And that's probably not what
+you want, so adjust it when you create your consumer instance.
+
+```ruby
+require 'krakow'
+
+consumer = Krakow::Consumer(
+  :nsqlookupd => 'http://HOST:PORT',
+  :topic => 'target',
+  :channel => 'ship',
+  :max_in_flight => 30
+)
+```
+
+### Please make it shutup!
+
+Sure:
+
+```
+Krakow::Utils::Logging.level = :warn # :debug / :info / :warn / :error / :fatal
+```
+
+### Why is it forcing something called an "unready state"?
+
+Because forcing starvation is mean.
+
+### I just want to connect to a producer, not a lookup service
+
+Fine!
+
+```ruby
+consumer = Krakow::Consumer(
+  :host => 'HOST',
+  :port => 'PORT',
+  :topic => 'target',
+  :channel => 'ship',
+  :max_in_flight => 30
+)
+```
+Great for testing, but you really should use the lookup service in the "real world"
+
+### It doesn't work
+
+Create an issue on the github repository.
+
+#### It doesn't do `x`
+
+Create an issue, or even better, send a PR. Just base it off the `develop` branch.
+
 # Info
 * Repo: https://github.com/chrisroberts/krakow
 * IRC: Freenode @ spox
+
+[1] https://github.com/bitly/nsq
+[2] https://github.com/celluloid/celluloid

data/lib/krakow/command/cls.rb

@@ -10,6 +10,16 @@ module Krakow
         "#{name}\n"
       end
 
+      class << self
+        def ok
+          %w(CLOSE_WAIT)
+        end
+
+        def error
+          %w(E_INVALID)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/fin.rb

@@ -11,6 +11,12 @@ module Krakow
         "#{name} #{message_id}\n"
       end
 
+      class << self
+        def error
+          %w(E_INVALID E_FIN_FAILED)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/identify.rb

@@ -15,10 +15,27 @@ module Krakow
       end
 
       def to_line
-        payload = MultiJson.dump(arguments)
+        filtered = Hash[*
+          arguments.map do |key, value|
+            unless(value.nil?)
+              [key, value]
+            end
+          end.compact.flatten
+        ]
+        payload = MultiJson.dump(filtered)
         [name, "\n", payload.length, payload].pack('a*a*l>a*')
       end
 
+      class << self
+        def ok
+          %w(OK)
+        end
+
+        def error
+          %w(E_INVALID E_BAD_BODY)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/mpub.rb

@@ -14,6 +14,16 @@ module Krakow
         [name, ' ', topic_name, "\n", formatted_messages.length, messages.size, formatted_messages].pack('a*a*a*a*l>l>a*')
       end
 
+      class << self
+        def ok
+          %w(OK)
+        end
+
+        def error
+          %w(E_INVALID E_BAD_TOPIC E_BAD_BODY E_BAD_MESSAGE E_MPUB_FAILED)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/pub.rb

@@ -12,6 +12,16 @@ module Krakow
         [name, ' ', topic_name, "\n", message.length, message].pack('a*a*a*a*l>a*')
       end
 
+      class << self
+        def ok
+          %w(OK)
+        end
+
+        def error
+          %w(E_INVALID E_BAD_TOPIC E_BAD_MESSAGE E_PUB_FAILED)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/rdy.rb

@@ -11,6 +11,12 @@ module Krakow
         "#{name} #{count}\n"
       end
 
+      class << self
+        def error
+          %w(E_INVALID)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/req.rb

@@ -11,6 +11,12 @@ module Krakow
         "#{name} #{message_id} #{timeout}\n"
       end
 
+      class << self
+        def error
+          %w(E_INVALID E_REQ_FAILED)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/sub.rb

@@ -11,6 +11,16 @@ module Krakow
         "#{name} #{topic_name} #{channel_name}\n"
       end
 
+      class << self
+        def ok
+          %w(OK)
+        end
+
+        def error
+          %w(E_INVALID E_BAD_TOPIC E_BAD_CHANNEL)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command/touch.rb

@@ -11,6 +11,12 @@ module Krakow
         "#{name} #{message_id}\n"
       end
 
+      class << self
+        def error
+          %w(E_INVALID E_TOUCH_FAILED)
+        end
+      end
+
     end
   end
 end

data/lib/krakow/command.rb

@@ -3,6 +3,20 @@ module Krakow
 
     include Utils::Lazy
 
+    class << self
+
+      def ok
+        []
+      end
+
+      def error
+        []
+      end
+
+    end
+
+    attr_accessor :response
+
     # Return command name
     def name
       self.class.name.split('::').last.upcase
@@ -13,6 +27,16 @@ module Krakow
       raise NoMethodError.new 'No line conversion method defined!'
     end
 
+    def ok?(response)
+      response = response.content if response.is_a?(FrameType)
+      self.class.ok.include?(response)
+    end
+
+    def error?(response)
+      response = response.content if response.is_a?(FrameType)
+      self.class.error.include?(response)
+    end
+
     # Make all the commands available
     Dir.glob(File.join(File.dirname(__FILE__), 'command', '*')).each do |path|
       autoload(

data/lib/krakow/connection.rb

@@ -16,41 +16,70 @@ module Krakow
       required! :host, :port
       optional :version, :queue, :callback
       arguments[:queue] ||= Queue.new
+      arguments[:responses] ||= Queue.new
       arguments[:version] ||= 'v2'
       @socket = TCPSocket.new(host, port)
     end
 
+    def to_s
+      "<#{self.class.name}:#{object_id} {#{host}:#{port}}>"
+    end
+
     # Initialize the connection
     def init!
+      debug 'Initializing connection'
       socket.write version.rjust(4).upcase
       async.process_to_queue!
+      info 'Connection initialized'
     end
 
     # message:: Command instance to send
     # Send the message
     def transmit(message)
-      socket.write message.to_line
+      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
+        end
+      end
     end
 
     # Cleanup prior to destruction
     def goodbye_my_love!
+      debug 'Tearing down connection'
       if(socket && !socket.closed?)
         socket.write Command::Cls.new.to_line
         socket.close
       end
       @socket = nil
+      info 'Connection torn down'
     end
 
     # Receive message and return proper FrameType instance
     def receive
-      buf = socket.read(8)
+      debug 'Read wait for frame start'
+      buf = socket.recv(8)
       if(buf)
         @receiving = true
+        debug "<<< #{buf.inspect}"
         struct = FrameType.decode(buf)
-        struct[:data] = socket.read(struct[:size])
+        debug "Decoded structure: #{struct.inspect}"
+        struct[:data] = socket.recv(struct[:size])
+        debug "<<< #{struct[:data].inspect}"
         @receiving = false
-        FrameType.build(struct)
+        frame = FrameType.build(struct)
+        debug "Struct: #{struct.inspect} Frame: #{frame.inspect}"
+        frame
       else
+        if(socket.closed?)
+          raise Error.new("#{self} encountered closed socket!")
+        end
         nil
       end
     end
@@ -65,6 +94,7 @@ module Krakow
       loop do
         message = handle(receive)
         if(message)
+          debug "Adding message to queue #{message}"
           queue << message
         end
       end
@@ -75,11 +105,18 @@ module Krakow
     def handle(message)
       # Grab heartbeats upfront
       if(message.is_a?(FrameType::Response) && message.response == '_heartbeat_')
-        socket.write Command::Nop.new.to_line
+        debug 'Responding to heartbeat'
+        transmit Command::Nop.new
         nil
       else
         if(callback && callback[:actor] && callback[:method])
-          callback[:actor].send(callback[:method], message, current_actor)
+          debug "Sending #{message} to callback `#{callback[:actor]}##{callback[:method]}`"
+          message = callback[:actor].send(callback[:method], message, current_actor)
+        end
+        if(!message.is_a?(FrameType::Message))
+          debug "Captured non-message type response: #{message}"
+          responses << message
+          nil
         else
           message
         end

data/lib/krakow/consumer.rb

@@ -4,82 +4,142 @@ module Krakow
     include Utils::Lazy
     include Celluloid
 
+    trap_exit :connection_failure
     finalizer :goodbye_my_love!
 
-    attr_reader :connections, :discovery, :queue
+    attr_reader :connections, :discovery, :distribution, :queue
 
     def initialize(args={})
       super
       required! :topic, :channel
-      optional :host, :port, :nslookupd, :receive_count
+      optional :host, :port, :nslookupd, :max_in_flight
+      arguments[:max_in_flight] ||= 1
       @connections = {}
+      @distribution = Distribution::Default.new(
+        :max_in_flight => max_in_flight
+      )
       @queue = Queue.new
       if(nslookupd)
+        debug "Connections will be established via lookup #{nslookupd.inspect}"
         @discovery = Discovery.new(:nslookupd => nslookupd)
         every(60){ init! }
         init!
-      else
+      elsif(host && port)
+        debug "Connection will be established via direct connection #{host}:#{port}"
         connection = build_connection(host, port, queue)
         if(register(connection))
-          connections[:default] = connection
+          info "Registered new connection #{connection}"
+          distribution.redistribute!
         else
-          raise Error.new("Failed to establish subscription at provided end point (#{host}:#{port}")
+          abort ConnectionFailure.new("Failed to establish subscription at provided end point (#{host}:#{port}")
         end
+      else
+        abort ConfigurationError.new('No connection information provided!')
       end
     end
 
+    def to_s
+      "<#{self.class.name}:#{object_id} T:#{topic} C:#{channel}>"
+    end
+
     def goodbye_my_love!
+      debug 'Tearing down consumer'
       connections.values.each do |con|
-        con.terminate
+        con.terminate if con.alive?
       end
+      distribution.terminate if distribution && distribution.alive?
+      info 'Consumer torn down'
     end
 
+    # host:: remote address
+    # port:: remote port
+    # queue:: message store queue
+    # Build new `Connection`
     def build_connection(host, port, queue)
       connection = Connection.new(
         :host => host,
         :port => port,
-        :queue => queue
+        :queue => queue,
+        :callback => {
+          :actor => current_actor,
+          :method => :process_message
+        }
       )
     end
 
+    # message:: FrameType
+    # connection:: Connection
+    # Process message if required
     def process_message(message, connection)
-      puts 'PROCESSING!'
       if(message.is_a?(FrameType::Message))
-        connection.transmit(Command::Rdy.new(:count => receive_count || 1))
+        distribution.register_message(message, connection)
       end
       message
     end
 
+    # connection:: Connection
+    # Send RDY for connection based on distribution rules
+    def update_ready!(connection)
+      distribution.set_ready_for(connection)
+    end
+
     # Requests lookup and adds connections
     def init!
+      debug 'Running consumer `init!` connection builds'
       found = discovery.lookup(topic)
+      debug "Discovery results: #{found.inspect}"
+      connection = nil
       found.each do |node|
-        unless(connections[node[:hostname]])
+        debug "Processing discovery result: #{node.inspect}"
+        key = "#{node[:broadcast_address]}_#{node[:tcp_port]}"
+        unless(connections[key])
           connection = build_connection(node[:broadcast_address], node[:tcp_port], queue)
-          connections[node[:hostname]] = connection if register(connection)
+          info "Registered new connection #{connection}" if register(connection)
+        else
+          debug "Discovery result already registered: #{node.inspect}"
         end
       end
+      distribution.redistribute! if connection
     end
 
     # connection:: Connection
     # Registers connection with subscription. Returns false if failed
     def register(connection)
-      connection.init!
-      connection.transmit(Command::Sub.new(:topic_name => topic, :channel_name => channel))
-      unless(connection.queue.pop.is_a?(FrameType::Error))
-        connection.transmit(Command::Rdy.new(:count => receive_count || 1))
+      begin
+        connection.init!
+        connection.transmit(Command::Sub.new(:topic_name => topic, :channel_name => channel))
+        self.link connection
+        connections["#{connection.host}_#{connection.port}"] = connection
+        distribution.add_connection(connection)
         true
-      else
+      rescue Error::BadResponse => e
+        debug "Failed to establish connection: #{e.result.error}"
         connection.terminate
         false
       end
     end
 
+    # con:: actor
+    # reason:: Exception
+    # Remove connection from register if found
+    def connection_failure(con, reason)
+      connections.delete_if do |key, value|
+        if(value == con)
+          warn "Connection failure detected. Removing connection: #{key}"
+          discovery.remove_connection(con)
+          true
+        end
+      end
+    end
+
     # message_id:: Message ID
     # Confirm message has been processed
     def confirm(message_id)
-      writer.transmit(Command::Fin.new(:message_id => message_id))
-      writer.transmit(Command::Rdy.new(:count => (receive_count - queue.size) + 1))
+      distribution.in_flight_lookup(message_id) do |connection|
+        connection.transmit(Command::Fin.new(:message_id => message_id))
+      end
+      connection = distribution.unregister_message(message_id)
+      update_ready!(connection)
       true
     end
 
@@ -87,14 +147,17 @@ module Krakow
     # timeout:: Requeue timeout (default is none)
     # Requeue message (processing failure)
     def requeue(message_id, timeout=0)
-      writer.transmit(Command::Req.new(:message_id => message_id, :timeout => timeout))
-    end
-
-    # Attempt to return free connection from pool for writing
-    def writer
-      connections.values.detect do |con|
-        !con.receiving?
-      end || connections.values.first
+      distribution.in_flight_lookup(message_id) do |connection|
+        connection.transmit(
+          Command::Req.new(
+            :message_id => message_id,
+            :timeout => timeout
+          )
+        )
+      end
+      connection = distributrion.unregister_message(message_id)
+      update_ready!(connection)
+      true
     end
 
   end

data/lib/krakow/discovery.rb

@@ -15,26 +15,31 @@ module Krakow
     # topic:: Topic name
     # Return list of end points with given topic name available
     def lookup(topic)
-      [nslookupd].flatten.map do |location|
+      result = [nslookupd].flatten.map do |location|
         uri = URI.parse(location)
         uri.path = '/lookup'
         uri.query = "topic=#{topic}&ts=#{Time.now.to_i}"
         begin
+          debug "Requesting lookup for topic #{topic} - #{uri}"
           content = HTTP.with(:accept => 'application/octet-stream').get(uri.to_s)
           unless(content.respond_to?(:to_hash))
             data = MultiJson.load(content.to_s)
           else
             data = content.to_hash
           end
+          debug "Lookup response (#{uri.to_s}): #{data.inspect}"
           if(data['data'] && data['data']['producers'])
             data['data']['producers'].map do |producer|
               Hash[*producer.map{|k,v| [k.to_sym, v]}.flatten]
             end
           end
         rescue => e
+          warn "Lookup exception encountered: #{e.class.name} - #{e}"
           nil
         end
       end.compact.flatten(1).uniq
+      debug "Discovery lookup result: #{result.inspect}"
+      result
     end
 
   end

data/lib/krakow/distribution/default.rb

@@ -0,0 +1,124 @@
+module Krakow
+  class Distribution
+    class Default < Distribution
+
+      attr_reader :less_than_ideal_stack, :watch_dog
+
+      # recalculate `ideal` and update RDY on connections
+      def redistribute!
+        @ideal = max_in_flight / registry.size
+        debug "Distribution calculated ideal: #{ideal}"
+        if(less_than_ideal?)
+          registry.each do |connection, reg_info|
+            reg_info[:ready] = 0
+          end
+          max_in_flight.times do
+            less_than_ideal_ready!
+          end
+          connections.each do |connection|
+            set_ready_for(connection, :force)
+          end
+          # TODO: Make interval configurable
+          watch_dog.cancel if watch_dog
+          @watch_dog = every(5) do
+            force_unready
+          end
+        else
+          if(watch_dog)
+            watch_dog.cancel
+            @watch_dog = nil
+          end
+          connections.each do |connection|
+            current_ready = ready_for(connection)
+            calculate_ready!(connection)
+            unless(current_ready == ready_for(connection))
+              debug "Redistribution ready setting update for connection #{connection}"
+              set_ready_for(connection)
+            end
+          end
+        end
+      end
+
+      # Returns if `ideal` is less than 1
+      def less_than_ideal?
+        ideal < 1
+      end
+
+      # Returns next connection to receive RDY count
+      def less_than_ideal_ready!
+        if(less_than_ideal_stack.nil? || less_than_ideal_stack.empty?)
+          @less_than_ideal_stack = waiting_connections
+        end
+        connection = less_than_ideal_stack.pop
+        if(connection)
+          registry_lookup(connection)[:ready] = 1
+          connection
+        end
+      end
+
+      # connection:: Connection
+      # args:: optional args (:force)
+      # Provides customized RDY set when less than ideal to round
+      # robin through connections
+      def set_ready_for(connection, *args)
+        if(less_than_ideal?)
+          if(args.include?(:force))
+            super connection
+          else
+            debug "RDY set ignored due to less than ideal state (con: #{connection})"
+            con = less_than_ideal_ready!
+            if(con)
+              watch_dog.reset if watch_dog
+              super con
+            else
+              warn 'Failed to set RDY state while less than ideal. Connection stack is empty!'
+            end
+          end
+        else
+          super connection
+        end
+      end
+
+      # connection:: Connection
+      # Update connection ready count
+      def calculate_ready!(connection)
+        registry_info = registry_lookup(connection)
+        unless(less_than_ideal?)
+          registry_info[:ready] = ideal - registry_info[:in_flight]
+          registry_info[:ready] = 0 if registry_info[:ready] < 0
+          registry_info[:ready]
+        else
+          registry_info[:ready] = 0
+        end
+      end
+
+      # Returns all connections without RDY state
+      def waiting_connections
+        registry.find_all do |connection, info|
+          info[:ready] < 1 && info[:in_flight] < 1
+        end.map(&:first).compact
+      end
+
+      # Returns all connections with RDY state
+      def rdy_connections
+        registry.find_all do |connection, info|
+          info[:ready] > 0
+        end.map(&:first).compact
+      end
+
+      # Force a connection to give up RDY state so next in stack can receive
+      def force_unready
+        debug 'Forcing a connection into an unready state due to less than ideal state'
+        connection = rdy_connections.shuffle.first
+        if(connection)
+          debug "Stripping RDY state from connection: #{connection}"
+          calculate_ready!(connection)
+          set_ready_for(connection)
+        else
+          warn "Failed to locate available connection for RDY aquisition!"
+        end
+      end
+
+    end
+  end
+end

data/lib/krakow/distribution.rb

@@ -0,0 +1,134 @@
+module Krakow
+  class Distribution
+
+    autoload :Default, 'krakow/distribution/default'
+#    autoload :ProducerWeighted, 'krakow/distribution/producer_weighted'
+#    autoload :ConsumerWeighted, 'krakow/distribution/consumer_weighted'
+
+    include Celluloid
+    include Utils::Lazy
+
+    attr_accessor :max_in_flight, :ideal, :flight_record, :registry
+
+    def initialize(args={})
+      super
+      @max_in_flight = arguments[:max_in_flight] || 1
+      @ideal = 0
+      @flight_record = {}
+      @registry = {}
+    end
+
+    # Reset flight distributions
+    def redistribute!
+      raise NoMethodError.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!'
+    end
+
+    # message:: FrameType::Message or message ID string
+    # Remove message metadata from registry. Should be used after
+    # confirmations or requeue.
+    def unregister_message(message)
+      msg_id = message.respond_to?(:message_id) ? message.message_id : message.to_s
+      connection = flight_record[msg_id]
+      # TODO: Add lookup error
+      registry_info = registry[connection_key(connection)]
+      flight_record.delete(msg_id)
+      registry_info[:in_flight] -= 1
+      calculate_ready!(connection)
+      connection
+    end
+
+    # connection:: Connection
+    # Return the currently configured RDY value for given connnection
+    def ready_for(connection)
+      registry_lookup(connection)[:ready]
+    end
+
+    # connection:: Connection
+    # Send RDY for given connection
+    def set_ready_for(connection)
+      connection.transmit(
+        Command::Rdy.new(
+          :count => ready_for(connection)
+        )
+      )
+    end
+
+    # Initial ready value used for new connections
+    def initial_ready
+      ideal > 0 ? 1 : 0
+    end
+
+    # message:: FrameType::Message
+    # connection:: Connection
+    # Registers message into registry and configures for distribution
+    def register_message(message, connection)
+      registry_info = registry_lookup(connection)
+      registry_info[:in_flight] += 1
+      flight_record[message.message_id] = connection_key(connection)
+      calculate_ready!(connection)
+    end
+
+    # connection:: Connection
+    # Add connection to make available for RDY distribution
+    def add_connection(connection)
+      registry[connection_key(connection)] = {
+        :ready => initial_ready,
+        :in_flight => 0
+      }
+      true
+    end
+
+    # connection:: Connection
+    # Remove connection from RDY distribution
+    def remove_connection(connection)
+      # remove connection from registry
+      registry.delete(connection_key(connection))
+      # remove any in flight messages
+      in_flight.delete_if do |k,v|
+        v == connection_key(connection)
+      end
+      true
+    end
+
+    # connection:: Connection
+    # Return lookup key (actor reference)
+    def connection_key(connection)
+      connection.current_actor
+    end
+
+    # msg_id:: Message ID string
+    # Return source connection of given `msg_id`. If block is
+    # provided, the connection instance will be yielded to the block
+    # and the result returned.
+    def in_flight_lookup(msg_id)
+      connection = flight_record[msg_id]
+      unless(connection)
+        abort LookupFailed.new("Failed to locate in flight message (ID: #{msg_id})")
+      end
+      if(block_given?)
+        yield connection
+      else
+        connection
+      end
+    end
+
+    # connection:: Connection
+    # Return registry information for given connection
+    def registry_lookup(connection)
+      registry[connection_key(connection)] ||
+        abort(LookupFailed.new("Failed to locate connection information in registry (#{connection})"))
+    end
+
+    # Return list of all connections in registry
+    def connections
+      registry.keys
+    end
+
+  end
+end

data/lib/krakow/exceptions.rb

@@ -1,6 +1,10 @@
 module Krakow
   class Error < StandardError
 
+    class LookupFailed < Error; end
+    class ConnectionFailure < Error; end
+    class ConfigurationError < Error; end
+
     class BadResponse < Error
       attr_accessor :result
     end

data/lib/krakow/frame_type/error.rb

@@ -7,6 +7,14 @@ module Krakow
         required! :error
       end
 
+      def error
+        arguments[:error]
+      end
+
+      def content
+        error
+      end
+
     end
   end
 end

data/lib/krakow/frame_type/message.rb

@@ -7,6 +7,10 @@ module Krakow
         required! :attempts, :timestamp, :message_id, :message
       end
 
+      def content
+        message
+      end
+
     end
   end
 end

data/lib/krakow/frame_type/response.rb

@@ -7,6 +7,10 @@ module Krakow
         required! :response
       end
 
+      def content
+        response
+      end
+
     end
   end
 end

data/lib/krakow/frame_type.rb

@@ -46,5 +46,9 @@ module Krakow
       super
     end
 
+    def content
+      raise NoMethodError.new 'Content method not properly defined!'
+    end
+
   end
 end

data/lib/krakow/producer.rb

@@ -4,6 +4,7 @@ module Krakow
     include Utils::Lazy
     include Celluloid
 
+    trap_exit  :connection_failure
     finalizer :goodbye_my_love!
 
     attr_reader :connection
@@ -11,43 +12,96 @@ module Krakow
     def initialize(args={})
       super
       required! :host, :port, :topic
-      @connection = Connection.new(:host => host, :port => port)
-      connection.init!
+      optional :connect_retries
+      arguments[:reconnect_retries] ||= 10
+      arguments[:reconnect_interval] = 5
+      connect
+    end
+
+    # Establish connection to configured `host` and `port`
+    def connect
+      info "Establishing connection to: #{host}:#{port}"
+      begin
+        @connection = Connection.new(:host => host, :port => port)
+        self.link connection
+        connection.init!
+        info "Connection established: #{connection}"
+      rescue => e
+        abort e
+      end
+    end
+
+    def to_s
+      "<#{self.class.name}:#{object_id} {#{host}:#{port}} T:#{topic}>"
+    end
+
+    # Return if connected
+    def connected?
+      connection && connection.alive?
+    end
+
+    # 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
     end
 
     def goodbye_my_love!
-      if(connection)
+      debug 'Tearing down producer'
+      if(connection && connection.alive?)
         connection.terminate
       end
       @connection = nil
+      info 'Producer torn down'
     end
 
     # message:: Message to send
     # Write message
     def write(*message)
-      if(message.size > 1)
-        connection.transmit(
-          Command::Mpub.new(
-            :topic_name => topic,
-            :messages => message
+      if(connection.alive?)
+        if(message.size > 1)
+          debug 'Multiple message publish'
+          connection.transmit(
+            Command::Mpub.new(
+              :topic_name => topic,
+              :messages => message
+            )
           )
-        )
-      else
-        connection.transmit(
-          Command::Pub.new(
-            :message => message.first,
-            :topic_name => topic
+        else
+          debug 'Single message publish'
+          connection.transmit(
+            Command::Pub.new(
+              :message => message.first,
+              :topic_name => topic
+            )
           )
-        )
+        end
+        read(:validate)
+      else
+        abort Error.new 'Remote connection is unavailable!'
       end
-      read(:validate)
     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.queue.pop
+      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

data/lib/krakow/utils/lazy.rb

@@ -1,6 +1,9 @@
 module Krakow
   module Utils
     module Lazy
+
+      include Utils::Logging
+
       attr_reader :arguments
 
       def initialize(args={})
@@ -33,6 +36,14 @@ module Krakow
         end
       end
 
+      def to_s
+        "<#{self.class.name}:#{object_id}>"
+      end
+
+      def inspect
+        "<#{self.class.name}:#{object_id} [#{arguments.inspect}]>"
+      end
+
       def method_missing(*args)
         key = args.first.to_sym
         if(arguments.has_key?(key))

data/lib/krakow/utils/logging.rb

@@ -0,0 +1,32 @@
+module Krakow
+  module Utils
+    module Logging
+
+      # Define base logging types
+      %w(debug info warn error).each do |key|
+        define_method(key) do |string|
+          log(key, string)
+        end
+      end
+
+      # Log message
+      def log(*args)
+        if(args.empty?)
+          Celluloid::Logger
+        else
+          severity, string = args
+          Celluloid::Logger.send(severity.to_sym, "#{self}: #{string}")
+        end
+      end
+
+      class << self
+        def level=(level)
+          if(Celluloid.logger.class == Logger)
+            Celluloid.logger.level = Logger.const_get(level.to_s.upcase.to_sym)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/krakow/utils.rb

@@ -1,5 +1,6 @@
 module Krakow
   module Utils
     autoload :Lazy, 'krakow/utils/lazy'
+    autoload :Logging, 'krakow/utils/logging'
   end
 end

data/lib/krakow/version.rb

@@ -3,5 +3,5 @@ require 'krakow'
 module Krakow
   class Version < Gem::Version
   end
-  VERSION = Version.new('0.0.1')
+  VERSION = Version.new('0.1.0')
 end

data/lib/krakow.rb

@@ -6,6 +6,7 @@ module Krakow
   autoload :Connection, 'krakow/connection'
   autoload :Consumer, 'krakow/consumer'
   autoload :Discovery, 'krakow/discovery'
+  autoload :Distribution, 'krakow/distribution'
   autoload :Error, 'krakow/exceptions'
   autoload :FrameType, 'krakow/frame_type'
   autoload :Producer, 'krakow/producer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: krakow
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-24 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -70,8 +70,11 @@ files:
 - lib/krakow/frame_type.rb
 - lib/krakow/command.rb
 - lib/krakow/version.rb
+- lib/krakow/distribution.rb
 - lib/krakow/utils/lazy.rb
+- lib/krakow/utils/logging.rb
 - lib/krakow/producer.rb
+- lib/krakow/distribution/default.rb
 - lib/krakow/frame_type/response.rb
 - lib/krakow/frame_type/error.rb
 - lib/krakow/frame_type/message.rb