rt-tackle 0.9 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b51e7b8dd21855f3c3a88d9da4be12c54a715d69
-  data.tar.gz: b4efab4ce923c03a8891099568192400ca085db4
+  metadata.gz: de0f2580c2937c203f50d01d0a8e7a66c8ad4cbe
+  data.tar.gz: 249a5fabc8c8dc812a69d8541ae3ab7c8e046d3e
 SHA512:
-  metadata.gz: 37f17e2b31c9b00c927dd3611ddc24b95b82e348f8ae33534b29df4bdc275507cc63b04df991ba26b42ae13f58f366e00e4771c06d8b3cc684b92e5d86623c69
-  data.tar.gz: 3e6743290efe3377fe2842c9930ffe86b5322e3ac7247d24860560cb5efaed2914936bdfb32c603ca888c94107a989e4d673d61def947ee95b94c3112711dc92
+  metadata.gz: 784cb5cfec47ace9f60d6ddabdb5b7d117f31e76cba8c38b6960b318ca73cca851ec39f5d84c16f64df9485db5b63b24db467c83f89e155e80aab007a8712b3b
+  data.tar.gz: 099fac7e24bc267a4c6556e1706c46fde7d823a007215b66e5842d077add917b48d8830d2b75aa50d0efb69a946b31fa1a7e11bdc765db90e3f3a7b5ac40ddc8

data/README.md

@@ -125,69 +125,6 @@ Tackle.consume(options) do |message|
 end
 ```
 
-### [DEPRECATED] Subscribe to an exchange
-
-**Deprecation notice:** For newer projects please use `Tackle.consume`.
-
-To consume messages from an exchange, do the following:
-
-```ruby
-require "tackle"
-
-options = {
-  :url => "amqp://localhost",
-  :exchange => "test-exchange",
-  :routing_key => "test-messages",
-  :queue => "test-queue"
-}
-
-Tackle.subscribe(options) do |message|
-  puts message
-end
-```
-
-By default, tackle will retry any message that fails to be consumed. To
-configure the retry limit and the delay in which the messages will be retried,
-do the following:
-
-```ruby
-require "tackle"
-
-options = {
-  :url => "amqp://localhost",
-  :exchange => "test-exchange",
-  :routing_key => "test-messages",
-  :queue => "test-queue",
-  :retry_limit => 8,
-  :retry_delay => 30
-}
-
-Tackle.subscribe(options) do |message|
-  puts message
-end
-```
-
-Tackle uses the `STDOUT` by default to trace the state of incoming messages. You
-can pass a dedicated logger to the `subscribe` method to redirect the output:
-
-```ruby
-require "tackle"
-
-options = {
-  :url => "amqp://localhost",
-  :exchange => "test-exchange",
-  :routing_key => "test-messages",
-  :queue => "test-queue",
-  :retry_limit => 8,
-  :retry_delay => 30,
-  :logger => Logger.new("subscribe.log")
-}
-
-Tackle.subscribe(options) do |message|
-  puts message
-end
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then,

data/lib/tackle/connection.rb

@@ -0,0 +1,41 @@
+module Tackle
+  class Connection
+    attr_reader :channel
+
+    def initialize(amqp_url, exception_handler, logger)
+      @amqp_url = amqp_url
+      @exception_handler = exception_handler
+      @logger = logger
+
+      connect
+    end
+
+    def connect
+      @logger.info("Connecting to RabbitMQ")
+
+      @connection = Bunny.new(@amqp_url)
+      @connection.start
+
+      @logger.info("Connected to RabbitMQ")
+
+      @channel = @connection.create_channel
+      @channel.prefetch(1)
+      @channel.on_uncaught_exception(&@exception_handler)
+
+      @logger.info("Connected to channel")
+    rescue StandardError => ex
+      @logger.error("Error while connecting to RabbitMQ message='#{ex}'")
+
+      raise ex
+    end
+
+    def close
+      @channel.close
+      @logger.info("Closed channel")
+
+      @connection.close
+      @logger.info("Closed connection to RabbitMQ")
+    end
+
+  end
+end

data/lib/tackle/consumer.rb

@@ -1,6 +1,5 @@
 module Tackle
   require_relative "consumer/params"
-  require_relative "consumer/connection"
   require_relative "consumer/message"
   require_relative "consumer/exchange"
 
@@ -19,7 +18,7 @@ module Tackle
     end
 
     def setup_rabbit_connections
-      @connection = Connection.new(@params.amqp_url, @params.exception_handler, @logger)
+      @connection = Tackle::Connection.new(@params.amqp_url, @params.exception_handler, @logger)
 
       @exchange    = Exchange.new(@params.service, @params.routing_key, @connection, @logger)
       @main_queue  = MainQueue.new(@exchange, @connection, @logger)

data/lib/tackle/publisher.rb

@@ -1,49 +1,25 @@
 module Tackle
   class Publisher
-    include Tackle::TackleLogger
 
-    def initialize(exchange_name, routing_key, url, logger)
+    def initialize(url, exchange_name, routing_key, logger)
+      @url = url
       @exchange_name = exchange_name
       @routing_key = routing_key
-      @url = url
       @logger = logger
     end
 
     def publish(message)
-      tackle_log("Publishing message started exchange='#{@exchange_name}' routing_key='#{@routing_key}'")
-
-      with_rabbit_connection do |conn|
-        channel = conn.create_channel
-        tackle_log("Created a communication channel")
-
-        exchange = channel.direct(@exchange_name, :durable => true)
-        tackle_log("Declared the exchange")
-
-        exchange.publish(message, :routing_key => @routing_key, :persistent => true)
-      end
-
-      tackle_log("Publishing message finished exchange='#{@exchange_name}' routing_key='#{@routing_key}'")
-    end
-
-    private
-
-    def with_rabbit_connection
-      tackle_log("Establishing rabbit connection")
+      connection = Tackle::Connection.new(@url, nil, @logger)
 
-      conn = Bunny.new(@url)
-      conn.start
+      @logger.info("Declaring exchange='#{@exchange_name}'")
+      exchange = connection.channel.direct(@exchange_name, :durable => true)
+      @logger.info("Declared exchange='#{@exchange_name}'")
 
-      yield(conn)
-
-      tackle_log("Established rabbit connection")
-    rescue StandardError => ex
-      tackle_log("An exception occured while sending the message exception='#{ex.class.name}' message='#{ex.message}'")
-
-      raise ex
+      @logger.info("Publishing message exchange='#{@exchange_name}' routing_key='#{@routing_key}'")
+      exchange.publish(message, :routing_key => @routing_key, :persistent => true)
+      @logger.info("Publishing message finished exchange='#{@exchange_name}' routing_key='#{@routing_key}'")
     ensure
-      tackle_log("Clossing rabbit connection")
-
-      conn.close if conn
+      connection.close
     end
 
   end

data/lib/tackle/version.rb

@@ -1,3 +1,3 @@
 module Tackle
-  VERSION = "0.9"
+  VERSION = "1.0"
 end

data/lib/tackle.rb

@@ -1,54 +1,27 @@
 require "tackle/version"
+require "bunny"
+require "logger"
 
 module Tackle
-  require "tackle/worker"
+  require "tackle/connection"
   require "tackle/publisher"
   require "tackle/consumer"
 
-  def self.consume(params = {}, &block)
+  module_function
+
+  def consume(params = {}, &block)
     params   = Tackle::Consumer::Params.new(params)
     consumer = Tackle::Consumer.new(params)
 
     consumer.subscribe(&block)
   end
 
-  # deprecated
-  def self.subscribe(options = {}, &block)
-    # required
-    exchange_name = options.fetch(:exchange)
-    routing_key   = options.fetch(:routing_key)
-    queue_name    = options.fetch(:queue)
-
-    # optional
-    amqp_url    = options[:url]
-    retry_limit = options[:retry_limit]
-    retry_delay = options[:retry_delay]
-    logger      = options[:logger]
-    on_uncaught_exception = options[:on_uncaught_exception]
-
-    worker = Tackle::Worker.new(exchange_name,
-                                routing_key,
-                                queue_name,
-                                :url => amqp_url,
-                                :retry_limit => retry_limit,
-                                :retry_delay => retry_delay,
-                                :logger => logger,
-                                :on_uncaught_exception => on_uncaught_exception)
-
-    worker.subscribe(&block)
-  end
-
-  def self.publish(message, options = {})
-    # required
-    exchange_name = options.fetch(:exchange)
-    routing_key   = options.fetch(:routing_key)
-
-    # optional
-    amqp_url    = options[:url] || "amqp://localhost:5672"
-    logger      = options[:logger] || Logger.new(STDOUT)
-
-    publisher = Tackle::Publisher.new(exchange_name, routing_key, amqp_url, logger)
+  def publish(message, options = {})
+    url         = options.fetch(:url)
+    exchange    = options.fetch(:exchange)
+    routing_key = options.fetch(:routing_key)
+    logger      = options.fetch(:logger, Logger.new(STDOUT))
 
-    publisher.publish(message)
+    Tackle::Publisher.new(url, exchange, routing_key, logger).publish(message)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rt-tackle
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: '1.0'
 platform: ruby
 authors:
 - Rendered Text
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-07 00:00:00.000000000 Z
+date: 2016-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -96,8 +96,8 @@ files:
 - bin/setup
 - docs/consumer.png
 - lib/tackle.rb
+- lib/tackle/connection.rb
 - lib/tackle/consumer.rb
-- lib/tackle/consumer/connection.rb
 - lib/tackle/consumer/dead_queue.rb
 - lib/tackle/consumer/delay_queue.rb
 - lib/tackle/consumer/exchange.rb
@@ -105,12 +105,8 @@ files:
 - lib/tackle/consumer/message.rb
 - lib/tackle/consumer/params.rb
 - lib/tackle/consumer/queue.rb
-- lib/tackle/delayed_retry.rb
 - lib/tackle/publisher.rb
-- lib/tackle/rabbit.rb
-- lib/tackle/tackle_logger.rb
 - lib/tackle/version.rb
-- lib/tackle/worker.rb
 - reset_rabbit.sh
 - tackle.gemspec
 homepage: https://semaphoreci.com

data/lib/tackle/consumer/connection.rb

@@ -1,43 +0,0 @@
-module Tackle
-  class Consumer
-    class Connection
-      attr_reader :channel
-
-      def initialize(amqp_url, exception_handler, logger)
-        @amqp_url = amqp_url
-        @exception_handler = exception_handler
-        @logger = logger
-
-        connect
-      end
-
-      def connect
-        @logger.info("Connecting to RabbitMQ")
-
-        @connection = Bunny.new(@amqp_url)
-        @connection.start
-
-        @logger.info("Connected to RabbitMQ")
-
-        @channel = @connection.create_channel
-        @channel.prefetch(1)
-        @channel.on_uncaught_exception(&@exception_handler)
-
-        @logger.info("Connected to channel")
-      rescue StandardError => ex
-        @logger.error("Error while connecting to RabbitMQ message='#{ex}'")
-
-        raise ex
-      end
-
-      def close
-        @channel.close
-        @logger.info("Closed channel")
-
-        @connection.close
-        @logger.info("Closed connection to RabbitMQ")
-      end
-
-    end
-  end
-end

data/lib/tackle/delayed_retry.rb

@@ -1,36 +0,0 @@
-require "tackle/tackle_logger"
-
-module Tackle
-
-  class DelayedRetry
-    include Tackle::TackleLogger
-
-    def initialize(dead_letter_queue, properties, payload, retry_limit, logger)
-      @dead_letter_queue = dead_letter_queue
-      @properties = properties
-      @payload = payload
-      @retry_limit = retry_limit
-      @logger = logger
-    end
-
-    def schedule_retry
-      if retry_count < @retry_limit
-        tackle_log("Adding message to retry queue for retry #{retry_count + 1}/#{@retry_limit}")
-        @dead_letter_queue.publish(@payload, :headers => {:retry_count => retry_count + 1})
-      else
-        tackle_log("Reached #{retry_count} retries. Discarding message.")
-      end
-    end
-
-    private
-
-    def retry_count
-      if @properties.headers && @properties.headers["retry_count"]
-        @properties.headers["retry_count"]
-      else
-        0
-      end
-    end
-
-  end
-end

data/lib/tackle/rabbit.rb

@@ -1,87 +0,0 @@
-require "bunny"
-require "tackle/tackle_logger"
-
-module Tackle
-
-  class Rabbit
-    include Tackle::TackleLogger
-
-    attr_reader :channel, :dead_letter_queue, :queue, :exchange
-
-    def initialize(exchange_name, routing_key, queue_name, amqp_url, retry_delay, logger)
-      @exchange_name = exchange_name
-      @routing_key = routing_key
-      @queue_name = queue_name
-      @amqp_url = amqp_url
-      @retry_delay = retry_delay
-      @logger = logger
-    end
-
-    def connect
-      @conn = Bunny.new(@amqp_url)
-      @conn.start
-      tackle_log("Connected to RabbitMQ")
-
-      @channel = @conn.create_channel
-      @channel.prefetch(1)
-
-      tackle_log("Connected to channel")
-      connect_queue
-      connect_dead_letter_queue
-    rescue StandardError => ex
-      tackle_log("An exception occured while connecting to the server message='#{ex.message}'")
-
-      raise ex
-    end
-
-    def on_uncaught_exception(blk)
-      @channel.on_uncaught_exception(&blk)
-    end
-
-    def close
-      @channel.close
-      tackle_log("Closed channel")
-      @conn.close
-      tackle_log("Closed connection to RabbitMQ")
-    end
-
-    def dead_letter_exchange_name
-      "#{@exchange_name}.dead_letter_exchange"
-    end
-
-    def dead_letter_queue_name
-      "#{@queue_name}_dead_letters"
-    end
-
-    private
-
-    def connect_queue
-      @exchange = @channel.direct(@exchange_name, :durable => true)
-      tackle_log("Connected to exchange '#{@exchange_name}'")
-
-      @queue = @channel.queue(@queue_name, :durable => true).bind(@exchange, :routing_key => @routing_key)
-
-      tackle_log("Connected to queue '#{@queue_name}' with routing key '#{@routing_key}'")
-    end
-
-    def connect_dead_letter_queue
-      tackle_log("Connected to dead letter exchange '#{dead_letter_exchange_name}'")
-
-      dead_letter_exchange = @channel.fanout(dead_letter_exchange_name)
-
-      queue_options = {
-        :durable => true,
-        :arguments => {
-          "x-dead-letter-exchange" => @exchange_name,
-          "x-dead-letter-routing-key" => @routing_key,
-          "x-message-ttl" => @retry_delay
-        }
-      }
-
-      @dead_letter_queue = @channel.queue(dead_letter_queue_name, queue_options).bind(dead_letter_exchange, :routing_key => @routing_key)
-
-      tackle_log("Connected to dead letter queue '#{dead_letter_queue_name}'")
-    end
-
-  end
-end

data/lib/tackle/tackle_logger.rb

@@ -1,13 +0,0 @@
-module Tackle
-
-  module TackleLogger
-
-    def tackle_log(message)
-      pid = Process.pid
-
-      whole_message = "tackle - pid=#{pid} message=#{message}"
-
-      @logger.info(whole_message)
-    end
-  end
-end

data/lib/tackle/worker.rb

@@ -1,86 +0,0 @@
-require "tackle/rabbit"
-require "tackle/delayed_retry"
-
-module Tackle
-  class Worker
-    include Tackle::TackleLogger
-
-    attr_reader :rabbit
-
-    # Initializes now worker
-    #
-    # @param [String] exchange_name Name of the exchange queue is connected to.
-    # @param [String] routing_key Routing key for binding queue to exchange
-    # @param [String] queue_name Name of the queue worker is processing.
-    # @param [Hash] options Worker options for RabbitMQ connection, retries and logger.
-    #
-    # @option options [String] :url AMQP connection url. Defaults to 'localhost'
-    # @option options [Integer] :retry_limit Number of times message processing should be retried in case of an exception.
-    # @option options [Integer] :retry_delay Delay between processing retries. Dafaults to 30 seconds. Cannot be changed without deleting or renameing a queue.
-    # @option options [Logger] :logger Logger instance. Defaults to standard output.
-    #
-    # @api public
-    def initialize(exchange_name, routing_key, queue_name, options = {})
-      @queue_name = queue_name
-      @amqp_url = options[:url] || "amqp://localhost:5672"
-      @retry_limit = options[:retry_limit] || 8
-      @retry_delay = (options[:retry_delay] || 30) * 1000 #ms
-      @logger = options[:logger] || Logger.new(STDOUT)
-
-      @rabbit = Tackle::Rabbit.new(exchange_name,
-                                   routing_key,
-                                   @queue_name,
-                                   @amqp_url,
-                                   @retry_delay,
-                                   @logger)
-
-      @rabbit.connect
-      @rabbit.on_uncaught_exception(options[:on_uncaught_exception]) if options[:on_uncaught_exception]
-    end
-
-    # Subscribes for message deliveries
-    #
-    # @param [Block] Accepts a block that accepts message
-    #
-    # @api public
-    def subscribe(&block)
-      tackle_log("Subscribing to queue '#{@queue_name}'...")
-      rabbit.queue.subscribe(:manual_ack => true,
-                             :block => true) do |delivery_info, properties, payload|
-
-        tackle_log("Received message. Processing...")
-        process_message(delivery_info, properties, payload, block)
-        tackle_log("Done with processing message.")
-
-      end
-    rescue Interrupt => _
-      rabbit.close
-    rescue StandardError => ex
-      tackle_log("An exception occured message='#{ex.message}'")
-
-      raise ex
-    end
-
-    def process_message(delivery_info, properties, payload, block)
-      begin
-        tackle_log("Calling message processor...")
-        block.call(payload)
-        @rabbit.channel.ack(delivery_info.delivery_tag)
-        tackle_log("Successfully processed message")
-      rescue Exception => ex
-        tackle_log("Failed to process message. Received exception '#{ex}'")
-        try_again = Tackle::DelayedRetry.new(@rabbit.dead_letter_queue,
-                                             properties,
-                                             payload,
-                                             @retry_limit,
-                                             @logger)
-        try_again.schedule_retry
-        tackle_log("Sending negative acknowledgement to source queue...")
-        @rabbit.channel.nack(delivery_info.delivery_tag)
-        tackle_log("Negative acknowledgement sent")
-
-        raise ex
-      end
-    end
-  end
-end