krakow 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.0.1
+	* Initial release

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    krakow (0.1.0)
+      celluloid-io
+      http
+      multi_json
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    celluloid-io (0.15.0)
+      celluloid (>= 0.15.0)
+      nio4r (>= 0.5.0)
+    http (0.5.0)
+      http_parser.rb
+    http_parser.rb (0.6.0)
+    multi_json (1.8.4)
+    nio4r (0.5.0)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  krakow!

data/README.md

@@ -0,0 +1,36 @@
+# Krakow
+
+"KRAKOW! KRAKOW! Two direct hits!"
+
+## Spiff
+
+```ruby
+require 'krakow'
+
+producer = Krakow::Producer(
+  :host => 'HOST',
+  :port => 'PORT',
+  :topic => 'target'
+)
+producer.write('direct hit!')
+```
+
+## Zargons
+
+```ruby
+require 'krakow'
+
+consumer = Krakow::Consumer(
+  :nsqlookupd => 'http://HOST:PORT',
+  :topic => 'target',
+  :channel => 'ship'
+)
+
+message = consumer.queue.pop
+# do stuff
+consumer.confirm(message.message_id)
+```
+
+# Info
+* Repo: https://github.com/chrisroberts/krakow
+* IRC: Freenode @ spox

data/krakow.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'krakow/version'
+Gem::Specification.new do |s|
+  s.name = 'krakow'
+  s.version = Krakow::VERSION.version
+  s.summary = 'NSQ library'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'http://github.com/chrisroberts/krakow'
+  s.description = 'NSQ ruby library'
+  s.require_path = 'lib'
+  s.add_dependency 'celluloid-io'
+  s.add_dependency 'http'
+  s.add_dependency 'multi_json'
+  s.files = Dir['**/*']
+end

data/lib/krakow/command/cls.rb

@@ -0,0 +1,15 @@
+module Krakow
+  class Command
+    class Cls < Command
+
+      def initialize(args={})
+        super
+      end
+
+      def to_line
+        "#{name}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/fin.rb

@@ -0,0 +1,16 @@
+module Krakow
+  class Command
+    class Fin < Command
+
+      def initialize(args={})
+        super
+        required! :message_id
+      end
+
+      def to_line
+        "#{name} #{message_id}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/identify.rb

@@ -0,0 +1,24 @@
+require 'multi_json'
+
+module Krakow
+  class Command
+    class Identify < Command
+
+      def initialize(args={})
+        super
+        required! :short_id, :long_id
+        optional(
+          :feature_negotiation, :heartbeat_interval, :output_buffer_size,
+          :output_buffer_timeout, :tls_v1, :snappy, :deflate, :deflate_level,
+          :sample_rate
+        )
+      end
+
+      def to_line
+        payload = MultiJson.dump(arguments)
+        [name, "\n", payload.length, payload].pack('a*a*l>a*')
+      end
+
+    end
+  end
+end

data/lib/krakow/command/mpub.rb

@@ -0,0 +1,19 @@
+module Krakow
+  class Command
+    class Mpub < Command
+
+      def initialize(args={})
+        super
+        required! :topic_name, :messages
+      end
+
+      def to_line
+        formatted_messages = messages.map do |message|
+          [message.length, message].pack('l>a*')
+        end.join
+        [name, ' ', topic_name, "\n", formatted_messages.length, messages.size, formatted_messages].pack('a*a*a*a*l>l>a*')
+      end
+
+    end
+  end
+end

data/lib/krakow/command/nop.rb

@@ -0,0 +1,15 @@
+module Krakow
+  class Command
+    class Nop < Command
+
+      def initialize(args={})
+        super
+      end
+
+      def to_line
+        "#{name}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/pub.rb

@@ -0,0 +1,17 @@
+
+module Krakow
+  class Command
+    class Pub < Command
+
+      def initialize(args={})
+        super
+        required! :topic_name, :message
+      end
+
+      def to_line
+        [name, ' ', topic_name, "\n", message.length, message].pack('a*a*a*a*l>a*')
+      end
+
+    end
+  end
+end

data/lib/krakow/command/rdy.rb

@@ -0,0 +1,16 @@
+module Krakow
+  class Command
+    class Rdy < Command
+
+      def initialize(args={})
+        super
+        required! :count
+      end
+
+      def to_line
+        "#{name} #{count}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/req.rb

@@ -0,0 +1,16 @@
+module Krakow
+  class Command
+    class Req < Command
+
+      def initialize(args={})
+        super
+        required! :message_id, :timeout
+      end
+
+      def to_line
+        "#{name} #{message_id} #{timeout}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/sub.rb

@@ -0,0 +1,16 @@
+module Krakow
+  class Command
+    class Sub < Command
+
+      def initialize(args={})
+        super
+        required! :topic_name, :channel_name
+      end
+
+      def to_line
+        "#{name} #{topic_name} #{channel_name}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command/touch.rb

@@ -0,0 +1,16 @@
+module Krakow
+  class Command
+    class Touch < Command
+
+      def initialize(args={})
+        super
+        required! :message_id
+      end
+
+      def to_line
+        "#{name} #{message_id}\n"
+      end
+
+    end
+  end
+end

data/lib/krakow/command.rb

@@ -0,0 +1,25 @@
+module Krakow
+  class Command
+
+    include Utils::Lazy
+
+    # Return command name
+    def name
+      self.class.name.split('::').last.upcase
+    end
+
+    # Convert to line output
+    def to_line
+      raise NoMethodError.new 'No line conversion method defined!'
+    end
+
+    # Make all the commands available
+    Dir.glob(File.join(File.dirname(__FILE__), 'command', '*')).each do |path|
+      autoload(
+        File.basename(path).sub(File.extname(path), '').capitalize.to_sym,
+        File.join('krakow/command', File.basename(path).sub(File.extname(path), ''))
+      )
+    end
+
+  end
+end

data/lib/krakow/connection.rb

@@ -0,0 +1,89 @@
+require 'celluloid/io'
+require 'celluloid/autostart'
+
+module Krakow
+  class Connection
+
+    include Utils::Lazy
+    include Celluloid::IO
+
+    finalizer :goodbye_my_love!
+
+    attr_reader :socket
+
+    def initialize(args={})
+      super
+      required! :host, :port
+      optional :version, :queue, :callback
+      arguments[:queue] ||= Queue.new
+      arguments[:version] ||= 'v2'
+      @socket = TCPSocket.new(host, port)
+    end
+
+    # Initialize the connection
+    def init!
+      socket.write version.rjust(4).upcase
+      async.process_to_queue!
+    end
+
+    # message:: Command instance to send
+    # Send the message
+    def transmit(message)
+      socket.write message.to_line
+    end
+
+    # Cleanup prior to destruction
+    def goodbye_my_love!
+      if(socket && !socket.closed?)
+        socket.write Command::Cls.new.to_line
+        socket.close
+      end
+      @socket = nil
+    end
+
+    # Receive message and return proper FrameType instance
+    def receive
+      buf = socket.read(8)
+      if(buf)
+        @receiving = true
+        struct = FrameType.decode(buf)
+        struct[:data] = socket.read(struct[:size])
+        @receiving = false
+        FrameType.build(struct)
+      else
+        nil
+      end
+    end
+
+    # Currently in the process of receiving a message
+    def receiving?
+      !!@receiving
+    end
+
+    # Pull message and queue
+    def process_to_queue!
+      loop do
+        message = handle(receive)
+        if(message)
+          queue << message
+        end
+      end
+    end
+
+    # message:: FrameType instance
+    # Handle message if not an actual message
+    def handle(message)
+      # Grab heartbeats upfront
+      if(message.is_a?(FrameType::Response) && message.response == '_heartbeat_')
+        socket.write Command::Nop.new.to_line
+        nil
+      else
+        if(callback && callback[:actor] && callback[:method])
+          callback[:actor].send(callback[:method], message, current_actor)
+        else
+          message
+        end
+      end
+    end
+  end
+end

data/lib/krakow/consumer.rb

@@ -0,0 +1,101 @@
+module Krakow
+  class Consumer
+
+    include Utils::Lazy
+    include Celluloid
+
+    finalizer :goodbye_my_love!
+
+    attr_reader :connections, :discovery, :queue
+
+    def initialize(args={})
+      super
+      required! :topic, :channel
+      optional :host, :port, :nslookupd, :receive_count
+      @connections = {}
+      @queue = Queue.new
+      if(nslookupd)
+        @discovery = Discovery.new(:nslookupd => nslookupd)
+        every(60){ init! }
+        init!
+      else
+        connection = build_connection(host, port, queue)
+        if(register(connection))
+          connections[:default] = connection
+        else
+          raise Error.new("Failed to establish subscription at provided end point (#{host}:#{port}")
+        end
+      end
+    end
+
+    def goodbye_my_love!
+      connections.values.each do |con|
+        con.terminate
+      end
+    end
+
+    def build_connection(host, port, queue)
+      connection = Connection.new(
+        :host => host,
+        :port => port,
+        :queue => queue
+      )
+    end
+
+    def process_message(message, connection)
+      puts 'PROCESSING!'
+      if(message.is_a?(FrameType::Message))
+        connection.transmit(Command::Rdy.new(:count => receive_count || 1))
+      end
+      message
+    end
+
+    # Requests lookup and adds connections
+    def init!
+      found = discovery.lookup(topic)
+      found.each do |node|
+        unless(connections[node[:hostname]])
+          connection = build_connection(node[:broadcast_address], node[:tcp_port], queue)
+          connections[node[:hostname]] = connection if register(connection)
+        end
+      end
+    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))
+        true
+      else
+        connection.terminate
+        false
+      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))
+      true
+    end
+
+    # message_id:: Message ID
+    # 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
+    end
+
+  end
+end

data/lib/krakow/discovery.rb

@@ -0,0 +1,41 @@
+require 'uri'
+require 'http'
+require 'multi_json'
+
+module Krakow
+  class Discovery
+
+    include Utils::Lazy
+
+    def initialize(args={})
+      super
+      required! :nslookupd
+    end
+
+    # topic:: Topic name
+    # Return list of end points with given topic name available
+    def lookup(topic)
+      [nslookupd].flatten.map do |location|
+        uri = URI.parse(location)
+        uri.path = '/lookup'
+        uri.query = "topic=#{topic}&ts=#{Time.now.to_i}"
+        begin
+          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
+          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
+          nil
+        end
+      end.compact.flatten(1).uniq
+    end
+
+  end
+end

data/lib/krakow/exceptions.rb

@@ -0,0 +1,9 @@
+module Krakow
+  class Error < StandardError
+
+    class BadResponse < Error
+      attr_accessor :result
+    end
+
+  end
+end

data/lib/krakow/frame_type/error.rb

@@ -0,0 +1,12 @@
+module Krakow
+  class FrameType
+    class Error < FrameType
+
+      def initialize(args={})
+        super
+        required! :error
+      end
+
+    end
+  end
+end

data/lib/krakow/frame_type/message.rb

@@ -0,0 +1,12 @@
+module Krakow
+  class FrameType
+    class Message < FrameType
+
+      def initialize(args={})
+        super
+        required! :attempts, :timestamp, :message_id, :message
+      end
+
+    end
+  end
+end

data/lib/krakow/frame_type/response.rb

@@ -0,0 +1,12 @@
+module Krakow
+  class FrameType
+    class Response < FrameType
+
+      def initialize(args={})
+        super
+        required! :response
+      end
+
+    end
+  end
+end

data/lib/krakow/frame_type.rb

@@ -0,0 +1,50 @@
+module Krakow
+  class FrameType
+
+    autoload :Error, 'krakow/frame_type/error'
+    autoload :Message, 'krakow/frame_type/message'
+    autoload :Response, 'krakow/frame_type/response'
+
+    include Utils::Lazy
+
+    FRAME_TYPE_MAP = [
+      FrameType::Response,
+      FrameType::Error,
+      FrameType::Message
+    ]
+    SIZE_BYTES = 4
+
+    class << self
+
+      # bytes:: 8 bytes
+      # Return information about incoming frame
+      def decode(bytes)
+        size, type = bytes.unpack('l>l>')
+        {:size => size - SIZE_BYTES, :type => type}
+      end
+
+      # args:: arguments (:type, :data, :size)
+      # Build proper FrameType instance based on args
+      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
+
+    def initialize(args={})
+      super
+    end
+
+  end
+end

data/lib/krakow/producer.rb

@@ -0,0 +1,61 @@
+module Krakow
+  class Producer
+
+    include Utils::Lazy
+    include Celluloid
+
+    finalizer :goodbye_my_love!
+
+    attr_reader :connection
+
+    def initialize(args={})
+      super
+      required! :host, :port, :topic
+      @connection = Connection.new(:host => host, :port => port)
+      connection.init!
+    end
+
+    def goodbye_my_love!
+      if(connection)
+        connection.terminate
+      end
+      @connection = nil
+    end
+
+    # message:: Message to send
+    # Write message
+    def write(*message)
+      if(message.size > 1)
+        connection.transmit(
+          Command::Mpub.new(
+            :topic_name => topic,
+            :messages => message
+          )
+        )
+      else
+        connection.transmit(
+          Command::Pub.new(
+            :message => message.first,
+            :topic_name => topic
+          )
+        )
+      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
+      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

@@ -0,0 +1,52 @@
+module Krakow
+  module Utils
+    module Lazy
+      attr_reader :arguments
+
+      def initialize(args={})
+        @arguments = {}.tap do |hash|
+          args.each do |k,v|
+            hash[k.to_sym] = v
+          end
+        end
+      end
+
+      # args:: list of required keys
+      # Check that required keys exist in `arguments` hash. Raise
+      # error if not found
+      def required!(*args)
+        args.each do |key|
+          unless(arguments.has_key?(key.to_sym))
+            raise ArgumentError.new "Missing required option `#{key}`!"
+          end
+        end
+      end
+
+      # args:: list of required keys
+      # Optional keys for arguments
+      def optional(*args)
+        args.each do |key|
+          key = key.to_sym
+          unless(arguments.has_key?(key))
+            arguments[key] = nil
+          end
+        end
+      end
+
+      def method_missing(*args)
+        key = args.first.to_sym
+        if(arguments.has_key?(key))
+          arguments[key]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(key, *args)
+        key = key.to_sym
+        super || arguments.has_key?(key)
+      end
+
+    end
+  end
+end

data/lib/krakow/utils.rb

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

data/lib/krakow/version.rb

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

data/lib/krakow.rb

@@ -0,0 +1,15 @@
+autoload :Celluloid, 'celluloid'
+
+module Krakow
+
+  autoload :Command, 'krakow/command'
+  autoload :Connection, 'krakow/connection'
+  autoload :Consumer, 'krakow/consumer'
+  autoload :Discovery, 'krakow/discovery'
+  autoload :Error, 'krakow/exceptions'
+  autoload :FrameType, 'krakow/frame_type'
+  autoload :Producer, 'krakow/producer'
+  autoload :Utils, 'krakow/utils'
+  autoload :Version, 'krakow/version'
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: krakow
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  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: http
+  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: multi_json
+  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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/krakow.rb
+- lib/krakow/consumer.rb
+- lib/krakow/frame_type.rb
+- lib/krakow/command.rb
+- lib/krakow/version.rb
+- lib/krakow/utils/lazy.rb
+- lib/krakow/producer.rb
+- lib/krakow/frame_type/response.rb
+- lib/krakow/frame_type/error.rb
+- lib/krakow/frame_type/message.rb
+- lib/krakow/command/pub.rb
+- lib/krakow/command/cls.rb
+- lib/krakow/command/touch.rb
+- lib/krakow/command/fin.rb
+- lib/krakow/command/identify.rb
+- lib/krakow/command/req.rb
+- lib/krakow/command/nop.rb
+- lib/krakow/command/mpub.rb
+- lib/krakow/command/sub.rb
+- lib/krakow/command/rdy.rb
+- lib/krakow/connection.rb
+- lib/krakow/exceptions.rb
+- lib/krakow/utils.rb
+- lib/krakow/discovery.rb
+- Gemfile
+- README.md
+- krakow.gemspec
+- CHANGELOG.md
+- Gemfile.lock
+homepage: http://github.com/chrisroberts/krakow
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: NSQ library
+test_files: []
+has_rdoc: