fastly_nsq 0.13.2 → 1.0.2

data/lib/fastly_nsq/message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 class FastlyNsq::Message

data/lib/fastly_nsq/messenger.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module FastlyNsq::Messenger
-  DEFAULT_ORIGIN = 'Unknown'.freeze
+  DEFAULT_ORIGIN = 'Unknown'
   @originating_service = DEFAULT_ORIGIN
 
   module_function
 
-  def deliver(message:, on_topic:, originating_service: nil, meta: {})
+  def deliver(message:, topic:, originating_service: nil, meta: {})
     meta[:originating_service] = originating_service || self.originating_service
 
     payload = {
@@ -12,9 +14,7 @@ module FastlyNsq::Messenger
       meta: meta,
     }
 
-    producer_for(topic: on_topic) do |producer|
-      producer.write payload.to_json
-    end
+    producer_for(topic: topic) { |producer| producer.write payload.to_json }
   end
 
   def originating_service=(service)

data/lib/fastly_nsq/priority_queue.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class FastlyNsq::PriorityQueue < FastContainers::PriorityQueue
+  alias << push
+  alias length size
+
+  def shift
+    pop
+  rescue RuntimeError
+    nil
+  end
+end

data/lib/fastly_nsq/priority_thread_pool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class FastlyNsq::PriorityThreadPool < Concurrent::ThreadPoolExecutor
+  alias max_threads max_length
+
+  def initialize(*)
+    super
+
+    @queue = FastlyNsq::PriorityQueue.new(:max)
+  end
+
+  # tries to enqueue task
+  # @return [true, false] if enqueued
+  #
+  # @!visibility private
+  def ns_enqueue(*args, &task)
+    if !ns_limited_queue? || @queue.size < @max_queue
+      @queue.push([task, args[1..-1]], args[0])
+      true
+    else
+      false
+    end
+  end
+
+  # tries to assign task to a worker, tries to get one from @ready or to create new one
+  # @return [true, false] if task is assigned to a worker
+  #
+  # @!visibility private
+  def ns_assign_worker(*args, &task)
+    super(args[1..-1], &task)
+  end
+end

data/lib/fastly_nsq/producer.rb

@@ -1,41 +1,61 @@
-require 'forwardable'
-
-module FastlyNsq
-  class Producer
-    extend Forwardable
-    def_delegator :connection, :terminate
-    def_delegator :connection, :write
-
-    def initialize(topic:, tls_options: nil, connector: nil)
-      @topic       = topic
-      @tls_options = TlsOptions.as_hash(tls_options)
-      @connector   = connector
-      Timeout.timeout(5) do
-        sleep(0.1) until connection.connected?
-      end
-    rescue Timeout::Error => error
-      FastlyNsq.logger.error "Producer for #{topic} failed to connect!"
-      connection.terminate
-      raise error
-    end
+# frozen_string_literal: true
 
-    private
+class FastlyNsq::Producer
+  DEFAULT_CONNECTION_TIMEOUT = 5 # seconds
 
-    attr_reader :topic, :tls_options
+  attr_reader :topic, :connect_timeout, :connection, :logger
 
-    def connection
-      @connection ||= connector.new(params)
-    end
+  def initialize(topic:, tls_options: nil, logger: FastlyNsq.logger, connect_timeout: DEFAULT_CONNECTION_TIMEOUT)
+    @topic           = topic
+    @tls_options     = FastlyNsq::TlsOptions.as_hash(tls_options)
+    @connect_timeout = connect_timeout
+    @logger          = logger
 
-    def connector
-      @connector || FastlyNsq.strategy::Producer
-    end
+    connect
+  end
+
+  def terminate
+    connection.terminate
+    @connection = nil
+  end
+
+  def connected?
+    return false unless connection
+
+    connection.connected?
+  end
 
-    def params
-      {
-        nsqlookupd:  ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS').split(',').map(&:strip),
+  def write(message)
+    raise FastlyNsq::NotConnectedError unless connected?
+    connection.write message
+  end
+
+  def connect
+    lookupd = FastlyNsq.lookupd_http_addresses
+
+    @connection ||= Nsq::Producer.new(
+      tls_options.merge(
+        nsqlookupd:  lookupd,
         topic:       topic,
-      }.merge(tls_options)
+      ),
+    )
+
+    timeout_args = [connect_timeout, FastlyNsq::ConnectionFailed]
+
+    if RUBY_VERSION > '2.4.0'
+      timeout_args << "Failed connection to #{lookupd} within #{connect_timeout} seconds"
     end
+
+    Timeout.timeout(*timeout_args) { Thread.pass until connection.connected? }
+
+    true
+  rescue FastlyNsq::ConnectionFailed
+    logger.error { "Producer for #{topic} failed to connect!" }
+    terminate
+    raise
   end
+
+  private
+
+  attr_reader :tls_options
 end

data/lib/fastly_nsq/testing.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module FastlyNsq
+  class Testing
+    class << self
+      attr_accessor :__test_mode
+
+      def __set_test_mode(mode)
+        if block_given?
+          current_mode = __test_mode
+          begin
+            self.__test_mode = mode
+            yield
+          ensure
+            self.__test_mode = current_mode
+          end
+        else
+          self.__test_mode = mode
+        end
+      end
+
+      def disable!(&block)
+        __set_test_mode(:disable, &block)
+      end
+
+      def fake!(&block)
+        __set_test_mode(:fake, &block)
+      end
+
+      def inline!(&block)
+        __set_test_mode(:inline, &block)
+      end
+
+      def enabled?
+        __test_mode != :disable
+      end
+
+      def disabled?
+        __test_mode == :disable
+      end
+
+      def fake?
+        __test_mode == :fake
+      end
+
+      def inline?
+        __test_mode == :inline
+      end
+
+      def reset!
+        return unless enabled?
+        FastlyNsq::Messages.messages.clear
+      end
+    end
+  end
+
+  module Messages
+    def self.messages
+      @messages ||= Hash.new { |h, k| h[k] = [] }
+    end
+  end
+
+  class TestMessage
+    attr_reader :raw_body
+
+    def initialize(raw_body)
+      @raw_body = raw_body
+    end
+
+    def body
+      JSON.parse(JSON.dump(raw_body))
+    rescue JSON::ParserError
+      raw_body
+    end
+
+    def finish
+      FastlyNsq::Messages.messages.find { |_, ms| ms.delete(self) }
+    end
+
+    def requeue(*)
+      # sure
+      true
+    end
+  end
+
+  module ProducerTesting
+    def connected?
+      return super unless FastlyNsq::Testing.enabled?
+      @connected = true if @connected.nil?
+      @connected
+    end
+
+    def terminate
+      return super unless FastlyNsq::Testing.enabled?
+
+      @connected = false
+    end
+
+    def write(message)
+      return super unless FastlyNsq::Testing.enabled?
+
+      raise FastlyNsq::NotConnectedError unless connected?
+
+      test_message = TestMessage.new(message)
+      FastlyNsq::Messages.messages[topic] << test_message
+
+      if FastlyNsq::Testing.inline?
+        listener = FastlyNsq.manager.topic_listeners[topic]
+        return unless listener
+        listener.call test_message
+      end
+
+      true
+    end
+
+    def connection
+      return super unless FastlyNsq::Testing.enabled?
+      return nil unless connected?
+      self
+    end
+
+    def connect
+      return super unless FastlyNsq::Testing.enabled?
+      @connected = true
+    end
+
+    def messages
+      raise NoMethodError unless FastlyNsq::Testing.enabled?
+
+      FastlyNsq::Messages.messages[topic]
+    end
+  end
+
+  Producer.prepend(ProducerTesting)
+
+  module ListenerTesting
+    module ClassMethods
+      def messages(topic = nil)
+        return FastlyNsq::Messages.messages.values.flatten unless topic
+
+        FastlyNsq::Messages.messages[topic]
+      end
+
+      def drain(topic = nil)
+        topics = topic ? [topic] : FastlyNsq::Messages.messages.keys
+        topics.each do |t|
+          messages = FastlyNsq::Messages.messages[t]
+          next unless messages.any?
+          listener = FastlyNsq.manager.topic_listeners[t]
+          next unless listener
+
+          messages.dup.each { |message| listener.call(message) }
+        end
+      end
+
+      def clear
+        FastlyNsq::Messages.messages.clear
+      end
+    end
+
+    def self.prepended(klass)
+      klass.prepend(ClassMethods)
+      super
+    end
+
+    def terminate
+      return super unless FastlyNsq::Testing.enabled?
+
+      @connected = false
+    end
+
+    def connected?
+      return super unless FastlyNsq::Testing.enabled?
+      @connected = true if @connected.nil?
+
+      @connected
+    end
+
+    def drain
+      raise NoMethodError unless FastlyNsq::Testing.enabled?
+
+      self.class.drain(topic)
+    end
+
+    def messages
+      raise NoMethodError unless FastlyNsq::Testing.enabled?
+
+      self.class.messages(topic)
+    end
+  end
+
+  FastlyNsq::Listener.prepend(ListenerTesting)
+
+  module ConsumerTesting
+    module ClassMethods
+      def messages(topic = nil)
+        return FastlyNsq::Messages.messages.values.flatten unless topic
+
+        FastlyNsq::Messages.messages[topic]
+      end
+
+      def clear
+        FastlyNsq::Messages.messages.clear
+      end
+    end
+
+    def self.prepended(klass)
+      klass.prepend(ClassMethods)
+      super
+    end
+
+    def terminate
+      FastlyNsq::Testing.enabled? || super
+    end
+
+    def empty?
+      FastlyNsq::Testing.enabled? ? messages.empty? : super
+    end
+
+    def size
+      FastlyNsq::Testing.enabled? ? messages.size : super
+    end
+
+    def terminated?
+      FastlyNsq::Testing.enabled? ? false : super
+    end
+
+    def messages
+      raise NoMethodError unless FastlyNsq::Testing.enabled?
+
+      FastlyNsq::Messages.messages[topic]
+    end
+  end
+
+  FastlyNsq::Consumer.prepend(ConsumerTesting)
+end
+
+# Default to fake testing
+FastlyNsq::Testing.fake!

data/lib/fastly_nsq/tls_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FastlyNsq
   class TlsOptions
     def self.as_hash(context = nil)

data/lib/fastly_nsq/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FastlyNsq
-  VERSION = '0.13.2'.freeze
+  VERSION = '1.0.2'
 end

data/spec/{lib/fastly_nsq/cli_spec.rb → cli_spec.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fastly_nsq/cli'
 

data/spec/consumer_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq::Consumer do
+  let!(:topic)   { 'fnsq' }
+  let!(:channel) { 'fnsq' }
+  let!(:queue)   { nil }
+
+  subject { described_class.new(topic: topic, channel: channel, queue: queue) }
+
+  before { reset_topic(topic, channel: channel) }
+  before { expect { subject }.to eventually(be_connected).within(5) }
+
+  after { subject.terminate if subject.connected? }
+
+  it { should be_connected }
+
+  it 'should terminate' do
+    expect { subject.terminate }.to change(subject, :connected?).to(false)
+  end
+
+  describe 'with a specified queue' do
+    let!(:queue) { Queue.new }
+
+    it 'passes #queue to Nsq::Consumer' do
+      message = 'foo'
+
+      FastlyNsq::Messenger.deliver(message: message, topic: topic)
+
+      expect { queue.size }.to eventually(eq 1).within(15)
+      fastly_message = FastlyNsq::Message.new(queue.pop)
+
+      expect(fastly_message.data).to eq(message)
+      fastly_message.finish
+    end
+  end
+
+  it { should delegate(:size).to(:connection) }
+  it { should delegate(:terminate).to(:connection) }
+  it { should delegate(:pop).to(:connection) }
+  it { should delegate(:pop_without_blocking).to(:connection) }
+
+  describe 'with a message' do
+    let(:message) { 'foo' }
+
+    before { FastlyNsq::Messenger.deliver(message: message, topic: topic) }
+
+    it 'should not be empty' do
+      expect { subject }.to eventually(be_empty).within(15)
+    end
+
+    describe 'that has finished' do
+      before { subject.pop.finish }
+
+      it { should be_empty }
+    end
+  end
+end