fastly_nsq 0.13.2 → 1.0.2

data/env_configuration_for_local_gem_tests.yml

@@ -1,5 +0,0 @@
-NSQD_TCP_ADDRESS: '127.0.0.1:4150'
-NSQD_HTTP_ADDRESS: '127.0.0.1:4151'
-NSQLOOKUPD_TCP_ADDRESS: '127.0.0.1:4160'
-NSQLOOKUPD_HTTP_ADDRESS: '127.0.0.1:4161'
-FAKE_QUEUE: 'true'

data/example_config_class.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class MessageProcessor
-  def self.process(message)
-    FastlyNsq.logger.info("IN PROCESS: #{message}")
-
-    # Do Soemthing with message
-  end
-end
-
-FastlyNsq.configure do |config|
-  config.channel = 'my_channel'
-  config.logger = Logger.new
-  config.preprocessor = ->(_) { FastlyNsq.logger.info 'PREPROCESSESES' }
-
-  config.listener_config do |lc|
-    lc.add_topic('some_topic', MessageProcessor)
-    lc.add_topic('some_other_topic', MessageProcessor)
-  end
-end

data/examples/Rakefile

@@ -1,41 +0,0 @@
-require 'fastly_nsq/rake_task'
-
-# A list of topics and a channel will need to be passed in to the Rake task
-# when it is called.
-
-desc 'Listen to the messaging queue with the given channel.'
-
-FastlyNsq::RakeTask.new(:listen_task) do |task|
-  task.channel = 'some_channel'
-  task.topics  = { 'a_topic' => RespondsToProcess }
-end
-
-# A custom logger and preprocessor
-
-desc 'Listen to the messaging queue with the given channel.'
-
-FastlyNsq::RakeTask.new(:listen_task) do |task|
-  task.channel      = 'some_channel'
-  task.topics       = { 'a_topic' => RespondsToProcess }
-  task.preprocessor = ->(message) { StatsClient.log(message) }
-  task.logger       = Logger.new(STDERR)
-end
-
-#-------------------------------------------------------------------------------
-# In Rails, you can include the application environment. The task looks like:
-
-FastlyNsq::RakeTask.new(listen_task: :environment)
-
-#-------------------------------------------------------------------------------
-# It's also possible to define the rake task to allow for overriding channel
-# and topics when calling the rake task:
-
-FastlyNsq::RakeTask.new(:listen_task, %i[channel topics])
-
-# Then call the task:
-#   rake listen_task[my_channel, {topic: Processor}]
-
-#-------------------------------------------------------------------------------
-# Do the same thing and include the environment:
-
-FastlyNsq::RakeTask.new(:listen_task, %i[channel topics] => :environment)

data/lib/fastly_nsq/fake_backend.rb

@@ -1,114 +0,0 @@
-module FastlyNsq
-  module FakeBackend
-    @@logger = Logger.new(nil)
-    @@delay  = 0.5
-    @@queue  = []
-
-    def self.queue
-      @@queue
-    end
-
-    def self.queue=(message)
-      @@queue = message
-    end
-
-    def self.reset!
-      self.queue = []
-    end
-
-    def self.logger=(logger)
-      @@logger = logger
-    end
-
-    def self.logger
-      @@logger
-    end
-
-    def self.delay
-      @@delay
-    end
-
-    def self.delay=(delay)
-      @@delay = delay
-    end
-
-    class Producer
-      attr_reader :topic
-
-      def initialize(topic:, **)
-        @topic = topic
-      end
-
-      def connected?
-        true
-      end
-
-      def write(string)
-        message = Message.new(string, topic: topic)
-        queue.push(message)
-      end
-
-      def terminate
-        # noop
-      end
-
-      private
-
-      def queue
-        FakeBackend.queue
-      end
-    end
-
-    class Consumer
-      def initialize(nsqlookupd: nil, topic:, channel:, tls_v1: nil, tls_options: nil); end
-
-      def connected?
-        true
-      end
-
-      def pop(delay = FakeBackend.delay)
-        message = nil
-
-        until message
-          message = queue.pop
-          sleep delay
-        end
-
-        message
-      end
-
-      def pop_without_blocking
-        queue.pop
-      end
-
-      def size
-        queue.size
-      end
-
-      def empty?
-        queue.empty?
-      end
-
-      def terminate
-        # noop
-      end
-
-      private
-
-      def queue
-        FakeBackend.queue
-      end
-    end
-
-    class Message
-      attr_reader :topic, :body
-
-      def initialize(body, topic: nil)
-        @topic = topic
-        @body = body
-      end
-
-      def finish; end
-    end
-  end
-end

data/lib/fastly_nsq/listener/config.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module FastlyNsq
-  class Listener
-    class Config
-      attr_reader :topic_map
-
-      def initialize
-        @topic_map = {}
-      end
-
-      def add_topic(topic_name, processor)
-        FastlyNsq.logger.info("topic: #{topic_name} : klass #{processor}")
-        validate topic_name, processor
-        topic_map[topic_name] = processor
-      end
-
-      private
-
-      def validate(topic_name, processor)
-        unless  processor.respond_to? :process
-          error_msg = "ConfigurationError: processor: #{processor} for #{topic_name} does not respond to :process!"
-          FastlyNsq.logger.error error_msg
-          raise ::ConfigurationError, error_msg
-        end
-
-        if topic_map[topic_name]
-          FastlyNsq.logger.warn("topic: #{topic_name} was added more than once")
-        end
-      end
-    end
-  end
-end
-
-class ConfigurationError < StandardError; end

data/lib/fastly_nsq/rake_task.rb

@@ -1,78 +0,0 @@
-require 'rake'
-require 'rake/tasklib'
-
-module FastlyNsq
-  class RakeTask < Rake::TaskLib
-    attr_accessor :name, :channel, :topics, :preprocessor
-    attr_writer :listener, :logger
-
-    def initialize(*args, &task_block)
-      @name = args.shift || :begin_listening
-      add_rake_task_description_if_one_needed
-
-      task(name, *args) do |_, task_args|
-        RakeFileUtils.send(:verbose, verbose) do
-          if block_given?
-            yield(*[self, task_args].slice(0, task_block.arity))
-          end
-
-          initialize_values task_args
-          listen_to_configured_topics
-        end
-      end
-    end
-
-    private
-
-    def listen_to_configured_topics
-      topic_per_thread do |topic, processor|
-        logger.info "Listening to queue, topic:'#{topic}' and channel: '#{channel}'"
-        listener.listen_to topic:        topic,
-                           channel:      channel,
-                           logger:       logger,
-                           processor:    processor,
-                           preprocessor: preprocessor
-        logger.info "... done listening on topic:'#{topic}' and channel: '#{channel}'."
-      end
-    end
-
-    def require_arg(arg, arg_list)
-      arg_list.fetch(arg) { raise ArgumentError, "required configuration '#{arg}' is missing." }
-    end
-
-    def add_rake_task_description_if_one_needed
-      unless ::Rake.application.last_description
-        desc 'Listen to NSQ on topic using channel'
-      end
-    end
-
-    def topic_per_thread
-      listener_threads = []
-      topics.each do |(topic, processor)|
-        thread = Thread.new do
-          yield topic, processor
-        end
-        thread.abort_on_exception = true
-        listener_threads << thread
-      end
-
-      listener_threads.map(&:join)
-    end
-
-    def listener
-      @listener || FastlyNsq::Listener
-    end
-
-    def logger
-      @logger || FastlyNsq.logger || Logger.new(STDOUT)
-    end
-
-    def initialize_values(task_args)
-      @channel      ||= require_arg :channel, task_args
-      @topics       ||= require_arg :topics, task_args
-      @listener     ||= task_args[:listener]
-      @logger       ||= task_args[:logger]
-      @preprocessor ||= task_args[:preprocessor]
-    end
-  end
-end

data/lib/fastly_nsq/strategy.rb

@@ -1,36 +0,0 @@
-module FastlyNsq
-  module Strategy
-    class InvalidParameterError < StandardError; end
-
-    module_function
-
-    def for_queue
-      real_queue || fake_queue || error
-    end
-
-    ERR_MESSAGE = "You must set ENV['FAKE_QUEUE'] to either true or false".freeze
-
-    def error
-      raise InvalidParameterError, ERR_MESSAGE
-    end
-
-    FALSY_VALUES  = [false, 0, '0', 'false', 'FALSE', 'off', 'OFF', nil].freeze
-    TRUTHY_VALUES = [true, 1, '1', 'true', 'TRUE', 'on', 'ON'].freeze
-
-    def fake_queue
-      FastlyNsq::FakeBackend if should_use_fake_queue?
-    end
-
-    def should_use_real_queue?
-      FALSY_VALUES.include? ENV['FAKE_QUEUE']
-    end
-
-    def real_queue
-      Nsq if should_use_real_queue?
-    end
-
-    def should_use_fake_queue?
-      TRUTHY_VALUES.include? ENV['FAKE_QUEUE']
-    end
-  end
-end

data/spec/lib/fastly_nsq/consumer_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FastlyNsq::Consumer do
-  let(:channel)  { 'star_killer_base' }
-  let(:topic)    { 'death_star' }
-  let(:consumer) { FastlyNsq::Consumer.new topic: topic, channel: channel }
-
-  describe 'when connected to a backend Consumer' do
-    let(:backend)   { instance_double FastlyNsq::FakeBackend::Consumer, pop: nil, pop_without_blocking: nil, size: nil, terminate: nil, connected?: true }
-    let(:connector) { double 'Connector strategy', new: backend }
-
-    let(:consumer) do
-      FastlyNsq::Consumer.new topic: topic, channel: channel, connector: connector
-    end
-
-    it 'forwards #pop' do
-      expect(backend).to receive(:pop)
-      consumer.pop
-    end
-
-    it 'forwards #pop_without_blocking' do
-      expect(backend).to receive(:pop_without_blocking)
-      consumer.pop_without_blocking
-    end
-
-    it 'forwards #size' do
-      expect(backend).to receive(:size)
-      consumer.size
-    end
-
-    it 'forwards #terminate' do
-      expect(backend).to receive(:terminate)
-      consumer.terminate
-    end
-  end
-
-  describe 'using strategy to determine the consumer' do
-    module TestStrategy
-      module Consumer
-        @@never_terminated = true
-
-        module_function
-
-        def new(*_)
-          self
-        end
-
-        def connected?
-          true
-        end
-
-        def terminate
-          raise 'Already terminated once' unless @@never_terminated
-          @@never_terminated = false
-        end
-
-        def was_terminated
-          !@@never_terminated
-        end
-      end
-    end
-
-    before do
-      allow(FastlyNsq).to receive(:strategy).and_return(TestStrategy)
-    end
-
-    it 'instantiates a consumer via Strategy' do
-      consumer.terminate
-      expect(TestStrategy::Consumer.was_terminated).to be_truthy
-    end
-  end
-end

data/spec/lib/fastly_nsq/fake_backend_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FastlyNsq::FakeBackend do
-  describe '@@queue' do
-    it 'is initalized as an empty array' do
-      expect(FastlyNsq::FakeBackend.queue).to eq []
-    end
-  end
-
-  describe '@@logger' do
-    after do
-      FastlyNsq::FakeBackend.logger = Logger.new(nil)
-    end
-
-    it 'is initalized as an empty Ruby Logger' do
-      expect(FastlyNsq::FakeBackend.logger).to be_a Logger
-    end
-
-    it 'can be set and retrieved' do
-      logger = double('some logger')
-      FastlyNsq::FakeBackend.logger = logger
-
-      expect(FastlyNsq::FakeBackend.logger).to eq logger
-    end
-  end
-
-  describe '.reset!' do
-    it 'resets the fake message queue' do
-      FastlyNsq::FakeBackend.queue = ['hello']
-      expect(FastlyNsq::FakeBackend.queue.size).to eq 1
-
-      FastlyNsq::FakeBackend.reset!
-
-      expect(FastlyNsq::FakeBackend.queue).to be_empty
-    end
-  end
-end
-
-RSpec.describe FastlyNsq::FakeBackend::Producer do
-  let(:topic)    { 'death_star' }
-  let(:producer) { FastlyNsq::FakeBackend::Producer.new topic: topic }
-
-  it 'adds a new message to the queue' do
-    body = 'hello'
-
-    expect do
-      producer.write(body)
-    end.to change { FastlyNsq::FakeBackend.queue.size }.by(1)
-
-    message = FastlyNsq::FakeBackend.queue.shift
-
-    expect(message.topic).to eq(topic)
-    expect(message.body).to eq(body)
-  end
-
-  it 'has a `terminate` method which is a noop' do
-    expect(producer).to respond_to(:terminate)
-  end
-end
-
-RSpec.describe FastlyNsq::FakeBackend::Message do
-  describe '#body' do
-    it 'returns the body of the message' do
-      topic = 'death_star'
-      content = 'hello'
-      producer = FastlyNsq::FakeBackend::Producer.new(
-        nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-        topic: topic,
-      )
-      producer.write(content)
-
-      message = FastlyNsq::FakeBackend.queue.pop
-      body = message.body
-
-      expect(content).to eq body
-    end
-  end
-end
-
-RSpec.describe FastlyNsq::FakeBackend::Consumer do
-  let(:topic)    { 'death_star' }
-  let(:channel)  { 'star_killer_base' }
-  let(:consumer) { FastlyNsq::FakeBackend::Consumer.new topic: topic, channel: channel }
-
-  describe 'when there are no messages on the queue' do
-    it 'tells you there are 0 messages in the queue' do
-      expect(consumer.size).to eq 0
-    end
-
-    it 'blocks forever (until timeout) from #pop' do
-      FastlyNsq::FakeBackend.delay = 0.1
-      delay = FastlyNsq::FakeBackend.delay + 0.1
-
-      expect do
-        Timeout.timeout(delay) do
-          consumer.pop
-        end
-      end.to raise_error(Timeout::Error)
-    end
-
-    it 'returns nil from #pop_without_blocking' do
-      popped_message = consumer.pop_without_blocking
-
-      expect(popped_message).to be_nil
-    end
-  end
-
-  describe 'when there is a message on the queue' do
-    let(:message) { FastlyNsq::FakeBackend::Message.new 'hello' }
-    before { FastlyNsq::FakeBackend.queue = [message] }
-
-    it 'tells you there are messages in the queue' do
-      expect(consumer.size).to eq 1
-    end
-
-    it 'returns a message immediately from #pop' do
-      popped_message = consumer.pop
-
-      expect(popped_message).to eq message
-    end
-
-    it 'returns a message immediately from #pop_without_blocking' do
-      popped_message = consumer.pop_without_blocking
-
-      expect(popped_message).to eq message
-    end
-  end
-
-  describe '#terminate' do
-    it 'has a terminate method which is a noop' do
-      consumer = instance_double('FastlyNsq::FakeBackend::Consumer')
-      allow(consumer).to receive(:terminate)
-    end
-  end
-end