euston-daemons 1.0.4-java → 1.1.0-java

data/lib/euston-daemons/framework/queue.rb

@@ -1,71 +0,0 @@
-class RabbitMQClient
-  class Queue
-    include Hollywood
-
-    attr_writer :timeout
-
-    def delivery_timeout
-      @timeout ||= 500
-    end
-
-    def safe_subscribe
-      _consumer = self.consumer
-      until Thread.current[:stop] do
-        safe_subscribe_with_timeout(_consumer, self.delivery_timeout)
-      end
-    end
-
-    def safe_handle_message(msg)
-      begin
-        message = JSON.parse_sym(msg.body)
-        begin
-          callback :message_received, message
-          msg.ack!
-        rescue Euston::EventStore::ConcurrencyError
-          msg.reject! true #requeue
-        rescue => e
-          callback :message_failed, message, e, msg
-          Safely.report! e
-        end
-      rescue => e
-        callback :message_decode_failed, msg.body, e
-        msg.ack!
-        Safely.report! e
-      end
-    end
-
-    def consumer(auto_ack=false)
-        consumer = QueueingConsumer.new(@channel)
-        @channel.basic_consume(@name, auto_ack, consumer)
-        consumer
-    end
-
-    def safe_subscribe_with_timeout(consumer, timeout=500)
-      loop do
-        delivery = nil
-        begin
-          delivery = consumer.next_delivery(timeout)
-        rescue NativeException => e
-          Thread.current[:exception] = e
-          break
-        end
-        break if delivery.nil?
-        remsg = ReactiveMessage.new(@channel, delivery, String.from_java_bytes(delivery.get_body))
-        safe_handle_message remsg
-        @channel.basic_ack(delivery.envelope.delivery_tag, false) if remsg.should_acknowledge?
-      end
-    end
-  end
-
-  class ReactiveMessage
-    def reject(opts={})
-      self.reject!(opts.fetch(:requeue, true))
-    end
-    def ack(multiple=false)
-      self.ack!
-    end
-    def method()
-      self.envelope
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/components/buffer_component.rb

@@ -1,73 +0,0 @@
-module Euston
-  module MessageBufferDaemon
-    class BufferComponent
-      include Euston::Daemons::ComponentShutdown
-
-      class << self
-        def command_component pub_channel, sub_channel
-          self.new Publisher.commands_buffer(pub_channel), Subscriber.commands_buffer(sub_channel)
-        end
-
-        def event_component pub_channel, sub_channel
-          self.new Publisher.events_buffer(pub_channel), Subscriber.events_buffer(sub_channel)
-        end
-      end
-
-      attr_reader :pub_thread, :sub_thread
-      attr_writer :wait_time, :subscribe_timeout
-
-      def initialize pub_buffer, sub_buffer
-        @pub_buffer = pub_buffer
-        @sub_buffer = sub_buffer
-      end
-
-      def wait_time
-        @wait_time ||= 0.2
-      end
-
-      def subscribe_timeout
-        @subscribe_timeout ||= 2000
-      end
-
-      def thread_state
-        {:publish => @pub_thread.status, :subscribe => @sub_thread.status}
-      end
-
-      def stop
-        @pub_thread[:stop], @sub_thread[:stop] = true, true
-        @pub_buffer.disconnect
-        @sub_buffer.disconnect
-      end
-
-      def start
-        @pub_thread = Thread.new do
-          until Thread.current[:stop] do
-            begin
-              @msg_dispatched_count = 0
-              begin
-                @msg_dispatched_count = @pub_buffer.dispatch_due_messages
-                check_exception_and_shutdown
-              end until Thread.current[:stop] || @msg_dispatched_count.zero?
-            rescue => e
-              Thread.current[:exception] = e
-            end
-            check_exception_and_shutdown
-            sleep self.wait_time
-          end
-        end
-
-        @sub_thread = Thread.new do
-          until Thread.current[:stop] do
-            begin
-              @sub_buffer.dequeue_buffered_messages(self.subscribe_timeout)
-              check_exception_and_shutdown
-            rescue => e
-              Thread.current[:exception] = e
-            end
-            check_exception_and_shutdown
-          end
-        end
-      end
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/components/event_store_component.rb

@@ -1,52 +0,0 @@
-module Euston
-  module MessageBufferDaemon
-    class EventStoreComponent
-      include Euston::Daemons::ComponentShutdown
-
-      attr_reader :cli_thread
-      attr_writer :wait_time
-
-      def initialize channel
-        @channel = channel
-      end
-
-      def wait_time
-        @wait_time ||= 0.2
-      end
-
-      def start
-        @cli_thread = Thread.new do
-          @event_buffer = Euston::RabbitMq::ReadModel::MessageBuffer.events
-          @event_store = Euston::RabbitMq.event_store
-
-          until Thread.current[:stop] do
-            begin
-              loop do
-                commits = @event_store.get_undispatched_commits
-                break if commits.empty?
-                commits.each do |commit|
-                  commit.events.each { |event| @event_buffer.buffer_new_message event.to_hash }
-                  @event_store.mark_commit_as_dispatched commit
-                end
-              end
-            rescue => e
-              Thread.current[:exception] = e
-            end
-            check_exception_and_shutdown
-            sleep self.wait_time
-          end
-        end
-      end
-
-      def thread_state
-        @cli_thread.status
-      end
-
-      def stop
-        @cli_thread[:stop] = true
-        @channel.disconnect
-      end
-
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/message_logger.rb

@@ -1,54 +0,0 @@
-module Euston
-  class MessageLogger
-    class << self
-      def commands_logger channel
-        self.new channel, :commands
-      end
-
-      def events_logger channel
-        self.new channel, :events
-      end
-    end
-
-    include Euston::RabbitMq::Exchanges
-    include Euston::RabbitMq::Queues
-
-    def initialize channel, exchange_name
-      @channel = channel
-      @exchange = get_exchange channel, exchange_name
-      @read_model = Euston::MessageBufferDaemon::ReadModel::MessageLog.send exchange_name
-
-      @queue = get_queue channel, "#{exchange_name}_log"
-      @queue.bind @exchange, :routing_key => "#{exchange_name}.#"
-
-      @queue.when(:message_decode_failed => method(:log_failure),
-                  :message_failed        => method(:message_failed),
-                  :message_received      => method(:write_message_to_log))
-    end
-
-    def message_failed(message, error, header)
-      log_failure message, error
-      header.ack
-    end
-
-    def disconnect
-      @channel.disconnect
-    end
-
-    def start
-      @queue.safe_subscribe
-    end
-
-    def log_failure message, error
-      text = "A log queue subscription failed. [Error] #{error.message} [Payload] #{message}"
-      err = Euston::RabbitMq::MessageDecodeFailedError.new text
-      err.set_backtrace error.backtrace
-
-      Safely.report! err
-    end
-
-    def write_message_to_log message
-      @read_model.log_new_message message
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/publisher.rb

@@ -1,56 +0,0 @@
-module Euston
-  module MessageBufferDaemon
-    class Publisher
-      class << self
-        def commands_buffer channel
-          self.new channel, :commands
-        end
-
-        def events_buffer channel
-          self.new channel, :events
-        end
-      end
-
-      include Euston::RabbitMq::Exchanges
-
-      def initialize channel, exchange_name
-        @read_model = Euston::RabbitMq::ReadModel::MessageBuffer.send exchange_name
-
-        @channel = channel
-        @exchange = get_exchange @channel, exchange_name
-      end
-
-      def disconnect
-        @channel.disconnect
-      end
-
-      def dispatch_one_due_message
-        if (message = @read_model.find_next_message)
-          @read_model.set_next_attempt message
-          protected_publish(message)
-        end
-      end
-
-      def dispatch_due_messages
-        dispatched = 0
-        @read_model.find_due_messages.each do |message|
-          @read_model.set_next_attempt message
-          break unless protected_publish(message)
-          dispatched += 1
-        end
-        dispatched
-      end
-
-      def protected_publish(message)
-        ret = true
-        begin
-          @exchange.publish message['json'], default_publish_options.merge(:routing_key => "#{@exchange.name}.#{message['type']}")
-        rescue NativeException => e
-          Thread.current[:exception] = e
-          ret = false
-        end
-        ret
-      end
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/settings.rb

@@ -1,14 +0,0 @@
-module Euston
-  module MessageBufferDaemon
-    module Settings
-      def self.configure(cfg=nil)
-        @config ||= {}
-        @config.merge!(cfg) if cfg && cfg.is_a?(Hash)
-      end
-
-      def self.debug
-        @config[:debug]
-      end
-    end
-  end
-end

data/lib/euston-daemons/message_buffer_daemon/lib/subscriber.rb

@@ -1,60 +0,0 @@
-module Euston
-  module MessageBufferDaemon
-    class Subscriber
-      class << self
-        def commands_buffer channel
-          self.new channel, :commands
-        end
-
-        def events_buffer channel
-          self.new channel, :events
-        end
-      end
-
-      include Euston::RabbitMq::Exchanges
-      include Euston::RabbitMq::Queues
-      include Hollywood
-
-      def initialize channel, exchange_name
-        @read_model = Euston::RabbitMq::ReadModel::MessageBuffer.send exchange_name
-
-        @channel = channel
-        @channel.prefetch(1)
-        @exchange = get_exchange @channel, exchange_name
-        @queue = get_queue @channel, "#{exchange_name}_buffer"
-        @queue.bind @exchange, :routing_key => "#{exchange_name}.#"
-
-        @queue.when(:message_decode_failed => method(:log_failure),
-                    :message_failed        => method(:message_failed),
-                    :message_received      => method(:remove_message_from_buffer))
-
-        @consumer = @queue.consumer
-      end
-
-      def disconnect
-        @channel.disconnect
-      end
-
-      def dequeue_buffered_messages(timeout) #will block until message or timeout
-        @queue.safe_subscribe_with_timeout(@consumer, timeout)
-      end
-
-      def log_failure message, error
-        text = "A buffer queue subscription failed. [Error] #{error.message} [Payload] #{message}"
-        err = Euston::RabbitMq::MessageDecodeFailedError.new text
-        err.set_backtrace error.backtrace
-
-        Safely.report! err
-      end
-
-      def message_failed(message, error, header)
-        header.ack!
-        log_failure message, error
-      end
-
-      def remove_message_from_buffer message
-        @read_model.remove_published_message message[:headers][:id]
-      end
-    end
-  end
-end