nsq-krakow 0.1.0

data/lib/krakow/exceptions.rb

@@ -0,0 +1,30 @@
+require 'krakow'
+
+module Krakow
+  # Base error type
+  class Error < StandardError
+
+    # Failed to enable required feature on connection
+    class ConnectionFeatureFailure < Error; end
+    # Failed to perform lookup (not found)
+    class LookupFailed < Error; end
+    # Connection has failed
+    class ConnectionFailure < Error; end
+    # Configuration is not in valid state
+    class ConfigurationError < Error; end
+    # Connection is temporarily unavailable
+    class ConnectionUnavailable < Error; end
+    # Consumer was not set
+    class OriginNotFound < Error; end
+
+    # Invalid response
+    class BadResponse < Error
+      # @return [Response] error response
+      attr_accessor :result
+      # No response received
+      class NoResponse < BadResponse
+      end
+    end
+
+  end
+end

data/lib/krakow/frame_type.rb

@@ -0,0 +1,66 @@
+require 'krakow'
+
+module Krakow
+  # Received message
+  # @abstract
+  class FrameType
+
+    autoload :Error, 'krakow/frame_type/error'
+    autoload :Message, 'krakow/frame_type/message'
+    autoload :Response, 'krakow/frame_type/response'
+
+    include Utils::Lazy
+    # @!parse include Krakow::Utils::Lazy::InstanceMethods
+    # @!parse extend Krakow::Utils::Lazy::ClassMethods
+
+    # Registered frame types
+    FRAME_TYPE_MAP = [
+      FrameType::Response,
+      FrameType::Error,
+      FrameType::Message
+    ]
+    # Size bytes
+    SIZE_BYTES = 4
+
+    class << self
+
+      # Information about incoming frame
+      # @param bytes [String]
+      # @return [Hash]
+      def decode(bytes)
+        size, type = bytes.unpack('l>l>')
+        {:size => size - SIZE_BYTES, :type => type}
+      end
+
+      # Build proper FrameType instance based on args
+      # @param args [Hash]
+      # @option args [FrameType] :type class of frame
+      # @option args [String] :data
+      # @option args [Integer] :size
+      # @return [FrameType]
+      def build(args={})
+        klass = FRAME_TYPE_MAP[args[:type].to_i]
+        if(klass == FrameType::Response)
+          klass.new(:response => args[:data])
+        elsif(klass == FrameType::Error)
+          klass.new(:error => args[:data])
+        elsif(klass == FrameType::Message)
+          unpacked = args[:data].unpack("Q>s>a16a#{args[:size]}")
+          klass.new(
+            Hash[*([:timestamp, :attempts, :message_id, :message].zip(unpacked).flatten)]
+          )
+        else
+          raise TypeError.new "Unknown frame type received: #{args[:type].inspect} - #{klass.inspect}"
+        end
+      end
+    end
+
+    # Content of message
+    #
+    # @return [String]
+    def content
+      raise NotImplementedError.new 'Content method not properly defined!'
+    end
+
+  end
+end

data/lib/krakow/frame_type/error.rb

@@ -0,0 +1,26 @@
+require 'krakow'
+
+module Krakow
+  class FrameType
+    # Error from server
+    class Error < FrameType
+
+      # @!group Attributes
+
+      # @!macro [attach] attribute
+      #   @!method $1
+      #     @return [$2] the $1 $0
+      #   @!method $1?
+      #     @return [TrueClass, FalseClass] truthiness of the $1 $0
+      attribute :error, String, :required => true
+
+      # @!endgroup
+
+      # @return [String] content of error
+      def content
+        error
+      end
+
+    end
+  end
+end

data/lib/krakow/frame_type/message.rb

@@ -0,0 +1,74 @@
+require 'krakow'
+
+module Krakow
+  class FrameType
+    # Message received from server
+    class Message < FrameType
+
+      # @return [Float] time of message instance creation
+      attr_reader :instance_stamp
+      attr_accessor :origin, :connection
+
+      # @!group Attributes
+
+      # @!macro [attach] attribute
+      #   @!method $1
+      #     @return [$2] the $1 $0
+      #   @!method $1?
+      #     @return [TrueClass, FalseClass] truthiness of the $1 $0
+      attribute :attempts, Integer, :required => true
+      attribute :timestamp, Integer, :required => true
+      attribute :message_id, String, :required => true
+      attribute :message, String, :required => true
+
+      # @!endgroup
+
+      def initialize(*args)
+        super
+        @instance_stamp = Time.now.to_f
+      end
+
+      # Message content
+      #
+      # @return [String]
+      def content
+        message
+      end
+
+      # @return [Krakow::Consumer]
+      def origin
+        unless(@origin)
+          error 'No origin has been specified for this message'
+          abort Krakow::Error::OriginNotFound.new('No origin specified for this message')
+        end
+        @origin
+      end
+
+      # @return [Krakow::Connection]
+      def connection
+        unless(@connection)
+          error 'No origin connection has been specified for this message'
+          abort Krakow::Error::ConnectionNotFound.new('No connection specified for this message')
+        end
+        @connection
+      end
+
+      # Proxy to [Krakow::Consumer#confirm]
+      def confirm(*args)
+        origin.confirm(*[self, *args].compact)
+      end
+      alias_method :finish, :confirm
+
+      # Proxy to [Krakow::Consumer#requeue]
+      def requeue(*args)
+        origin.requeue(*[self, *args].compact)
+      end
+
+      # Proxy to [Krakow::Consumer#touch]
+      def touch(*args)
+        origin.touch(*[self, *args].compact)
+      end
+
+    end
+  end
+end

data/lib/krakow/frame_type/response.rb

@@ -0,0 +1,26 @@
+require 'krakow'
+
+module Krakow
+  class FrameType
+    # Response from server
+    class Response < FrameType
+
+      # @!group Attributes
+
+      # @!macro [attach] attribute
+      #   @!method $1
+      #     @return [$2] the $1 $0
+      #   @!method $1?
+      #     @return [TrueClass, FalseClass] truthiness of the $1 $0
+      attribute :response, String, :required => true
+
+      # @!endgroup
+
+      # @return [String] content of response
+      def content
+        response
+      end
+
+    end
+  end
+end

data/lib/krakow/ksocket.rb

@@ -0,0 +1,102 @@
+require 'krakow'
+require 'socket'
+
+module Krakow
+  class Ksocket
+
+    include Utils::Lazy
+    include Celluloid
+
+    # @return [String]
+    attr_reader :buffer
+
+    finalizer :closedown_socket
+
+    # Teardown helper
+    def closedown_socket
+      @writing = @reading = false
+      if(socket && !socket.closed?)
+        socket.close
+      end
+    end
+
+    # Create new socket wrapper
+    #
+    # @param args [Hash]
+    # @option args [Socket-ish] :socket
+    # @option args [String] :host
+    # @option args [Integer] :port
+    # @return [self]
+    def initialize(args={})
+      if(args[:socket])
+        @socket = args[:socket]
+      else
+        unless([:host, :port].all?{|k| args.include?(k)})
+          raise ArgumentError.new 'Missing required arguments. Expecting `:socket` or `:host` and `:port`.'
+        end
+        @socket = TCPSocket.new(args[:host], args[:port])
+      end
+      @buffer = ''
+      async.read_loop
+    end
+
+    # @return [TrueClass, FalseClass] read loop enabled
+    def reading?
+      !!@reading
+    end
+
+    # Read from socket and push into local Queue
+    def read_loop
+      unless(reading?)
+        @reading = true
+        while(reading?)
+          res = defer do
+            Kernel.select([socket], nil, nil, nil)
+            socket{|s| s.readpartial(1024)}
+          end
+          if(res)
+            debug "Received content from socket: #{res.inspect}"
+            buffer << res
+            signal(:content_read)
+          else
+            debug 'No content received from socket read. Ignoring.'
+          end
+        end
+      end
+    end
+
+    # Fetch bytes from socket
+    #
+    # @param n [Integer]
+    # @return [String]
+    def get(n)
+      until(buffer.length >= n)
+        wait(:content_read)
+      end
+      buffer.slice!(0, n)
+    end
+    alias_method :recv, :get
+    alias_method :read, :get
+    alias_method :sysread, :get
+    alias_method :readpartial, :get
+
+    # Push bytes to socket
+    #
+    # @param line [String]
+    # @return [Integer]
+    def put(line)
+      socket{|s| s.write(line)}
+    end
+    alias_method :write, :put
+
+    # @return [Socket]
+    def socket
+      if(block_given?)
+        yield @socket
+      else
+        @socket
+      end
+    end
+
+  end
+end

data/lib/krakow/producer.rb

@@ -0,0 +1,162 @@
+require 'krakow'
+
+module Krakow
+
+  # TCP based producer
+  class Producer
+
+    autoload :Http, 'krakow/producer/http'
+
+    include Utils::Lazy
+    # @!parse include Utils::Lazy::InstanceMethods
+    # @!parse extend Utils::Lazy::ClassMethods
+
+    include Celluloid
+
+    trap_exit  :connection_failure
+    finalizer :producer_cleanup
+
+    # set exclusive methods
+    exclusive :write
+
+    attr_reader :connection
+    attr_reader :notifier
+
+    # @!group Attributes
+
+    # @!macro [attach] attribute
+    #   @!method $1
+    #     @return [$2] the $1 $0
+    #   @!method $1?
+    #     @return [TrueClass, FalseClass] truthiness of the $1 $0
+    attribute :host, String, :required => true
+    attribute :port, [String, Integer], :required => true
+    attribute :topic, String, :required => true
+    attribute :reconnect_retries, Integer, :default => 10
+    attribute :reconnect_interval, Integer, :default => 5
+    attribute :connection_options, Hash, :default => ->{ Hash.new }
+
+    # @!endgroup
+
+    def initialize(args={})
+      super
+      arguments[:connection_options] = {:features => {}, :config => {}, :options => {}}.merge(
+        arguments.fetch(:connection_options, {})
+      )
+      connect
+    end
+
+    # Establish connection to configured `host` and `port`
+    #
+    # @return nil
+    def connect
+      @connecting = true
+      info "Establishing connection to: #{host}:#{port}"
+      begin
+        con_args = connection_options[:options].dup.tap do |args|
+          args[:host] = host
+          args[:port] = port
+          if(connection_options[:features])
+            args[:features] = connection_options[:features]
+          end
+          if(connection_options[:config])
+            args[:features_args] = connection_options[:config]
+          end
+        end
+        @connection = Connection.new(con_args)
+        @connection.init!
+        self.link @connection
+        info "Connection established: #{@connection}"
+        nil
+      rescue => e
+        abort e
+      end
+      @connecting = false
+    end
+
+    # @return [String] stringify object
+    def to_s
+      "<#{self.class.name}:#{object_id} {#{host}:#{port}} T:#{topic}>"
+    end
+
+    # @return [TrueClass, FalseClass] currently connected to server
+    def connected?
+      begin
+        !!(!@connecting &&
+          connection &&
+          connection.alive? &&
+          connection.connected?)
+      rescue Celluloid::DeadActorError
+        false
+      end
+    end
+
+    # Process connection failure and attempt reconnection
+    #
+    # @return [TrueClass]
+    def connection_failure(obj, reason)
+      if(obj == connection && !reason.nil?)
+        begin
+          @connection = nil
+          warn "Connection failure detected for #{host}:#{port} - #{reason}"
+          obj.terminate if obj.alive?
+          connect
+        rescue => reason
+          warn "Failed to establish connection to #{host}:#{port}. Pausing #{reconnect_interval} before retry"
+          sleep reconnect_interval
+          retry
+        end
+      end
+      true
+    end
+
+    # Instance destructor
+    # @return nil
+    def producer_cleanup
+      debug 'Tearing down producer'
+      if(connection && connection.alive?)
+        connection.terminate
+      end
+      @connection = nil
+      info 'Producer torn down'
+      nil
+    end
+
+    # Write message to server
+    #
+    # @param message [String] message to write
+    # @return [Krakow::FrameType, TrueClass]
+    # @note if connection response wait is set to 0, writes will
+    #   return a `true` value on completion
+    # @raise [Krakow::Error::ConnectionUnavailable]
+    def write(*message)
+      if(message.empty?)
+        abort ArgumentError.new 'Expecting one or more messages to send. None provided.'
+      end
+      begin
+        if(message.size > 1)
+          debug 'Multiple message publish'
+          connection.transmit(
+            Command::Mpub.new(
+              :topic_name => topic,
+              :messages => message
+            )
+          )
+        else
+          debug 'Single message publish'
+          connection.transmit(
+            Command::Pub.new(
+              :message => message.first,
+              :topic_name => topic
+            )
+          )
+        end
+      rescue Celluloid::Task::TerminatedError
+        abort Error::ConnectionUnavailable.new 'Connection is currently unavailable'
+      rescue => e
+        abort e
+      end
+    end
+
+  end
+end