surfliner-metadata_consumer 0.1.0.pre.alpha.4 → 0.1.0.pre.alpha.6

data/lib/surfliner/metadata_consumer/mq_config.rb

@@ -1,79 +0,0 @@
-module Surfliner
-  module MetadataConsumer
-    # An object encapsulating RabbitMQ configuration.
-    class MqConfig
-      # @return [String]  The RabbitMQ hostname
-      attr_reader :host
-
-      # @return [String]  The RabbitMQ AMQP port
-      attr_reader :port
-
-      # @return [String]  The RabbitMQ username
-      attr_reader :username
-
-      # @return [String]  The RabbitMQ passsword
-      attr_reader :password
-
-      # @return [String]  The topic exchange to listen to
-      attr_reader :topic
-
-      # @return [String]  The name of the queue to listen to
-      attr_reader :queue_name
-
-      # @return [String]  The platform routing key to listen to
-      attr_reader :routing_key
-
-      # Initializes a new `MqConfig` object.
-      # @param host [The] RabbitMQ hostname
-      # @param port [The] RabbitMQ AMQP port
-      # @param username [The] RabbitMQ username
-      # @param password [The] RabbitMQ passsword
-      # @param topic [The] topic exchange to listen to
-      # @param queue_name [The] name of the queue to listen to
-      # @param routing_key [The] platform routing key to listen to
-      def initialize(host:, port:, username:, password:, topic:, queue_name:, routing_key:)
-        @host = host
-        @port = port
-        @username = username
-        @password = password
-        @topic = topic
-        @queue_name = queue_name
-        @routing_key = routing_key
-      end
-
-      class << self
-        # Reads RabbitMQ configuration from environment variables and
-        # returns it as a new `MqConfig` object.
-        #
-        # - `RABBITMQ_HOST` → `host`
-        # - `RABBITMQ_NODE_PORT_NUMBER` → `port`
-        # - `RABBITMQ_USERNAME` → `username`
-        # - `RABBITMQ_PASSWORD` → `password`
-        # - `RABBITMQ_TOPIC` → `topic`
-        # - `RABBITMQ_QUEUE` → `queue_name`
-        # - `RABBITMQ_PLATFORM_ROUTING_KEY` → `routing_key`
-        def from_env
-          MqConfig.new(
-            host: ENV.fetch("RABBITMQ_HOST"),
-            port: ENV.fetch("RABBITMQ_NODE_PORT_NUMBER"),
-            username: ENV.fetch("RABBITMQ_USERNAME"),
-            password: ENV.fetch("RABBITMQ_PASSWORD"),
-            topic: ENV.fetch("RABBITMQ_TOPIC"),
-            queue_name: ENV.fetch("RABBITMQ_QUEUE"),
-            routing_key: ENV.fetch("RABBITMQ_PLATFORM_ROUTING_KEY")
-          )
-        end
-      end
-
-      # @return [String]  the connection URL as a string
-      def connection_url
-        @connection_url ||= "amqp://#{username}:#{password}@#{host}:#{port}"
-      end
-
-      # @return [String]  the connection URL as a string, without the password
-      def redacted_url
-        @redacted_url ||= connection_url.sub(password, "REDACTED")
-      end
-    end
-  end
-end

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