surfliner-metadata_consumer 0.1.0.pre.alpha.3 → 0.1.0.pre.alpha.5

data/lib/surfliner/metadata_consumer/mq_connection.rb

@@ -1,136 +0,0 @@
-require "bunny"
-
-module Surfliner
-  module MetadataConsumer
-    # An object encapsulating a RabbitMQ connection.
-    class MqConnection
-      # @return [Logger]  The logger
-      attr_reader :logger
-
-      # @return [Bunny::Session]  The current RabbitMQ session
-      attr_reader :connection
-
-      # @return [Bunny::Channel]  The channel being listened to
-      attr_reader :channel
-
-      # @return [Bunny::Exchange]  The exchange being listened to
-      attr_reader :exchange
-
-      # @return [Bunny::Queue]  The queue being listened to
-      attr_reader :queue
-
-      # @return [MqConfig]  The configuration
-      attr_reader :config
-
-      # Initializes a new `MqConnection`.
-      #
-      # @param logger [Logger] the logger
-      # @param config [MqConfig] the configuration
-      def initialize(logger:, config: MqConfig.from_env)
-        @logger = logger
-        @config = config
-      end
-
-      # Opens a connection.
-      # @param topic_opts [Hash] RabbitMQ topic options. (See Bunny::Channel#topic)
-      # @param queue_opts [Hash] RabbitMQ queue options. (See Bunny::Channel#queue)
-      # @return [self]
-      # @raise RuntimeError if already connected
-      def connect(topic_opts: {}, queue_opts: {})
-        raise "RabbitMQ connection #{connection} already open." if open?
-
-        logger.info("Rabbitmq message broker connection url: #{config.redacted_url}")
-        @connection = Bunny.new(config.connection_url, logger: logger)
-        connect_on(connection)
-        @channel = connection.create_channel
-        @exchange = channel.topic(config.topic, topic_opts)
-        @queue = channel.queue(config.queue_name, queue_opts)
-        queue.bind(exchange, routing_key: config.routing_key)
-
-        self
-      rescue Bunny::TCPConnectionFailed => err
-        # TODO: realistically, this only happens in connection.start, where we're eating it
-        logger.error("Connection to #{config.redacted_url} failed")
-        raise err
-      rescue Bunny::PossibleAuthenticationFailureError => err
-        # TODO: realistically, this only happens in connection.start, where we're eating it
-        logger.error("Failed to authenticate to #{config.redacted_url}")
-        raise err
-      end
-
-      # Opens a connection, yields the queue, and closes the connection after
-      # the provided block completes.
-      # @param topic_opts [Hash] RabbitMQ topic options. (See Bunny::Channel#topic)
-      # @param queue_opts [Hash] RabbitMQ queue options. (See Bunny::Channel#queue)
-      # @yield [Bunny::Queue]  the queue
-      def open(topic_opts: {}, queue_opts: {})
-        connect(topic_opts:, queue_opts:)
-        yield queue
-      ensure
-        close
-      end
-
-      # Closes the connection.
-      def close
-        return unless channel
-        return if channel.closed?
-        logger.info("closing channel")
-        channel.close
-      ensure
-        logger.info("closing connection")
-        connection&.close
-      end
-
-      # @return [true, false] True if the connection is open, false otherwise
-      def open?
-        connection&.status == :open
-      end
-
-      # @return [Symbol, nil] The connection status, or nil if there is no connection
-      def status
-        connection&.status
-      end
-
-      # @return [String]  The RabbitMQ hostname
-      def host
-        config.host
-      end
-
-      # @return [String]  The RabbitMQ port
-      def port
-        config.port
-      end
-
-      # @return [String] The routing key
-      def routing_key
-        config.routing_key
-      end
-
-      # Publishes the specified payload
-      # @param payload [String] the payload to publish
-      # @return [Bunny::Exchange] see #exchange
-      def publish(payload)
-        logger.info "Publishing to #{routing_key} with payload: #{payload}"
-        exchange.publish(payload, routing_key:)
-      end
-
-      private
-
-      def connect_on(connection, timeout = 120)
-        timer = 0
-        logger.info "Trying to open queue connection with timeout=#{timeout}"
-        while timer < timeout
-          begin
-            connection.start
-          rescue
-            # TODO: do we actually want to rescue from everything?
-          end
-          return connection if connection.status == :open
-          sleep 1
-          timer += 1
-        end
-        raise "Failed to connect to queue."
-      end
-    end
-  end
-end