euston-daemons 1.0.0-java

data/lib/euston-daemons/command_processor_daemon/lib/daemon.rb

@@ -0,0 +1,43 @@
+module Euston
+  module CommandProcessorDaemon
+    class Daemon
+      include Euston::Daemon
+
+      attr_reader :clients,:queue #,:ctx
+
+      def initialize #(ctx)
+        @queue = Queue.new
+        # @ctx = ctx
+        @clients = {}
+
+        Settings.client_instances.times do |i|
+          @clients["command_component_#{i.succ}"] = CommandHandlerComponent.new
+        end
+      end
+
+      def run
+        @clients.each do |name, component|
+          sleep 0.25
+          EUSTON_LOG.debug "Starting component: #{name}"
+          component.start
+        end
+
+        EUSTON_LOG.debug "Components started"
+
+        @clients.each do |name, component|
+          EUSTON_LOG.debug("Thread state of #{name}: #{component.thread_state.inspect}")
+        end
+
+        @queue.pop #<-------- stops here until interrupted
+
+        @clients.each do |name, component|
+          EUSTON_LOG.debug "Stopping component: #{name}"
+          component.stop
+        end
+
+        report_shutdown_reasons
+        EUSTON_LOG.debug "Components stopped"
+      end
+    end
+  end
+end

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

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

data/lib/euston-daemons/command_processor_daemon/rake_task.rb

@@ -0,0 +1,31 @@
+module Euston
+  class CommandProcessorRakeTask < Euston::Daemons::RakeTask
+    attr_accessor :amqp_config_path, :command_handler_namespaces, :daemon_config_path
+
+    def initialize
+      @command_handler_namespaces = []
+      super(:command_processor_daemon)
+    end
+
+    def before_creating_task
+      @daemon_path = File.expand_path(File.dirname __FILE__) + File::SEPARATOR
+      @daemon_class = 'Euston::CommandProcessorDaemon::Daemon'
+    end
+
+    def initialize_paths
+      EUSTON_LOG.debug "AMQP config path: #{@amqp_config_path}"
+      Object.const_set :AMQP_CONFIG_PATH, @amqp_config_path
+
+      EUSTON_LOG.debug "Daemon config path: #{@daemon_config_path}"
+      Object.const_set :DAEMON_CONFIG_PATH, @daemon_config_path
+
+      EUSTON_LOG.debug "Command handler namespaces: #{@command_handler_namespaces}"
+      Object.const_set :COMMAND_HANDLER_NAMESPACES, @command_handler_namespaces
+    end
+
+    def load_environment
+      EUSTON_LOG.debug "Loading environment"
+      require_rel 'config/environment.rb'
+    end
+  end
+end

data/lib/euston-daemons/event_processor_daemon/config/environment.rb

@@ -0,0 +1,20 @@
+require_rel '../components'
+require_rel '../lib'
+
+Safely::Strategy::Log.logger = EUSTON_LOG
+Cqrs.uuid = Uuid
+AMQP.settings.merge! ErbYaml.read(AMQP_CONFIG_PATH, EUSTON_ENV)
+Euston::EventProcessorDaemon::Settings.configure ErbYaml.read(DAEMON_CONFIG_PATH, EUSTON_ENV)
+
+hash = ErbYaml.read(MONGOID_CONFIG_PATH, EUSTON_ENV)
+
+read_connection = Mongo::Connection.new hash[:host], hash[:port], :safe => hash[:safe] #, :logger => EUSTON_LOG
+
+Mongoid.configure do |config|
+  config.master = Mongo::DB.new(hash[:read_model_database], read_connection)
+  config.logger = EUSTON_LOG
+end
+
+Cqrs::RabbitMq.read_model_mongodb = Mongo::DB.new(hash[:read_model_database], read_connection)
+
+I18n.load_path += Dir[I18N_LOCALES_PATH]

data/lib/euston-daemons/event_processor_daemon/lib/components/event_handler_component.rb

@@ -0,0 +1,72 @@
+module Euston
+  module EventProcessorDaemon
+    class EventHandlerComponent
+      include Euston::Daemons::ComponentShutdown
+
+      attr_reader :channel, :cli_threads
+
+      def initialize()
+        @channel = AMQP::Channel.new
+        @channel.prefetch(1)
+        @event_handler_bindings = Cqrs::RabbitMq::EventHandlerBindings.new(@channel)
+
+        if Object.const_defined? 'EVENT_HANDLER_NAMESPACES'
+          EVENT_HANDLER_NAMESPACES.each do |handler_namespace|
+            ns = Object
+            found = true
+
+            handler_namespace.split('::').each do |c|
+              if found && ns.const_defined?(c)
+                ns = ns.const_get c.to_sym
+              elsif found
+                EUSTON_LOG.warn "Couldn't find requested event handler namespace: #{handler_namespace}"
+                found = false
+              end
+            end
+
+            if found
+              EUSTON_LOG.debug "Successfully found event handler namespace: #{handler_namespace}"
+              @event_handler_bindings.add_namespace ns
+            end
+          end
+        end
+
+        @cli_threads = {}
+      end
+
+      def start
+        @event_handler_bindings.namespaced_handler_types.each do |namespace, handler_type|
+
+          @cli_threads["#{namespace}.#{handler_type}"] = Thread.new(namespace, handler_type) do |ns, ht|
+            begin
+              chan = AMQP::Channel.new
+              chan.prefetch(1)
+              EUSTON_LOG.debug "EventHandlerBinding for: #{ns}.#{ht}"
+              binding = Cqrs::RabbitMq::EventHandlerBinding.new(chan, ns, ht)
+              binding.bind
+              binding.listen
+            rescue => e
+              Thread.current[:exception] = e
+            ensure
+              chan.disconnect
+            end
+            check_exception_and_shutdown
+          end
+        end
+      end
+
+      def thread_state
+        out = {}
+        @cli_threads.each do |k, th|
+          out[k] = th.status
+        end
+        out.inspect
+      end
+
+      def stop
+        @cli_threads.values.each { |th| th[:stop] = true }
+        @channel.disconnect
+      end
+    end
+  end
+end

data/lib/euston-daemons/event_processor_daemon/lib/daemon.rb

@@ -0,0 +1,72 @@
+module Euston
+  module EventProcessorDaemon
+    class Daemon
+      include Euston::Daemon
+
+      #attr_reader :ctx,:servers,:bus,:queue,:event_handler
+      attr_reader :queue, :event_handler
+
+      def initialize() #ctx)
+        # @servers = []
+        # @ctx = ctx
+        # @queue = Queue.new
+
+        # bus_client_port = ReadDaemonSettings.bus_port_base
+        # bus_server_port = bus_client_port + 10
+
+        # BusComponentSettings.client_side_bind_address("tcp://*:#{bus_client_port}")
+        # BusComponentSettings.server_side_bind_address("tcp://*:#{bus_server_port}")
+        # ReadModelComponentSettings.bus_server_side_address("tcp://localhost:#{bus_server_port}")
+
+        # @bus = BusComponent.new(@ctx)
+
+        # ReadDaemonSettings.server_instances.times do
+        #   @servers << ReadModelComponent.new(@ctx)
+        # end
+
+        @queue = Queue.new
+        @event_handler = EventHandlerComponent.new
+      end
+
+      def run
+        # @bus.daemon = self
+        # @bus.start
+
+        # @servers.each do |ele|
+        #   sleep(0.5)
+        #   ele.daemon = self
+        #   ele.start
+        # end
+        @event_handler.daemon = self
+
+        name = 'event_handler'
+        EUSTON_LOG.debug "Starting component: #{name}"
+        @event_handler.start
+
+        EUSTON_LOG.debug "Components started"
+        EUSTON_LOG.debug "Thread state of #{name}: #{@event_handler.thread_state.inspect}"
+
+        # EUSTON_LOG.debug @bus.thread_state.inspect
+
+        # @servers.each do |svr|
+        #   EUSTON_LOG.debug "Server thread status: #{svr.thread_state}"
+        # end
+
+        @queue.pop  #<-------- stops here until interrupted
+
+        #exiting
+        # @servers.each do |ele|
+        #   ele.stop
+        # end
+        # sleep(0.6)
+        # @bus.stop
+
+        EUSTON_LOG.debug "Stopping component: #{name}"
+        @event_handler.stop
+
+        report_shutdown_reasons
+        EUSTON_LOG.debug "Components stopped"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Euston
+  module EventProcessorDaemon
+    module Settings
+      def self.configure(cfg=nil)
+        @config ||= {}
+        @config.merge!(cfg) if cfg && cfg.is_a?(Hash)
+      end
+      def self.server_instances
+        @config[:server_instances] || 2
+      end
+      def self.bus_port_base
+        (@config[:zmq_base_port] || 8200).to_i
+      end
+      def self.mongo_db_name
+        @config[:mongo_db_name]
+      end
+      def self.debug
+        @config[:debug]
+      end
+    end
+  end
+end

data/lib/euston-daemons/event_processor_daemon/rake_task.rb

@@ -0,0 +1,37 @@
+module Euston
+  class EventProcessorRakeTask < Euston::Daemons::RakeTask
+    attr_accessor :amqp_config_path, :daemon_config_path, :event_handler_namespaces, :i18n_locales_path, :mongoid_config_path
+
+    def initialize
+      @event_handler_namespaces = []
+      super(:event_processor_daemon)
+    end
+
+    def before_creating_task
+      @daemon_path = File.expand_path(File.dirname __FILE__) + File::SEPARATOR
+      @daemon_class = 'Euston::EventProcessorDaemon::Daemon'
+    end
+
+    def initialize_paths
+      EUSTON_LOG.debug "AMQP config path: #{@amqp_config_path}"
+      Object.const_set :AMQP_CONFIG_PATH, @amqp_config_path
+
+      EUSTON_LOG.debug "Daemon config path: #{@daemon_config_path}"
+      Object.const_set :DAEMON_CONFIG_PATH, @daemon_config_path
+
+      EUSTON_LOG.debug "Event handler namespaces: #{@event_handler_namespaces}"
+      Object.const_set :EVENT_HANDLER_NAMESPACES, @event_handler_namespaces
+
+      EUSTON_LOG.debug "i18n locales path: #{@i18n_locales_path}"
+      Object.const_set :I18N_LOCALES_PATH, @i18n_locales_path
+
+      EUSTON_LOG.debug "Mongoid config path: #{@mongoid_config_path}"
+      Object.const_set :MONGOID_CONFIG_PATH, @mongoid_config_path
+    end
+
+    def load_environment
+      EUSTON_LOG.debug "Loading environment"
+      require_rel 'config/environment.rb'
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Euston
+  module Daemons
+    class BasicComponent
+      include Euston::Daemons::ComponentShutdown
+
+      attr_reader :client, :cli_thread
+
+      def initialize(hosted_object)
+        @client = hosted_object
+      end
+
+      def start
+        @cli_thread = Thread.new do
+          begin
+            @client.start
+          rescue => e
+            Thread.current[:exception] = e
+          end
+          check_exception_and_shutdown
+        end
+      end
+
+      def thread_state
+        @cli_thread.status
+      end
+
+      def stop
+        @cli_thread[:stop] = true
+        @client.disconnect if @client.respond_to?(:disconnect)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Euston
+  module Daemons
+    module ComponentShutdown
+      attr_writer :daemon
+
+      def check_exception_and_shutdown(errors=[])
+        if errors.compact.empty?
+          errors << Thread.current[:exception]
+          return if errors.compact.empty?
+        end
+        errors.compact.each do |e|
+          if e.respond_to?(:cause) #its a serious (Java?) exception
+            Thread.current[:stop] = true
+            @daemon.irrecoverable_signal_from_component! e
+          else
+            Safely.report! e
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Euston
+  module Daemon
+    def errors
+      @errors ||= Queue.new
+    end
+
+    def irrecoverable_signal_from_component!(e)
+      self.errors.push e
+      @queue.push "SHUTDOWN"
+    end
+
+    def report_shutdown_reasons
+      sleep(0.25)
+      reports = []
+      until self.errors.empty? do
+        e = self.errors.pop(true) rescue nil
+        next if e.nil?
+        case e
+        when NativeException
+          Safely.report!(e.cause)
+        else
+          Safely.report!(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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 ::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