euston-daemons 1.0.5 → 1.2.1

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

@@ -1,25 +0,0 @@
-require 'jessica'
-require 'euston'
-require 'euston-eventstore'
-require 'euston-rabbitmq'
-require_rel '../lib'
-
-Safely::Strategy::Log.logger = EUSTON_LOG
-AMQP.settings.merge! ErbYaml.read(AMQP_CONFIG_PATH, EUSTON_ENV)
-Euston::CommandProcessorDaemon::Settings.configure ErbYaml.read(DAEMON_CONFIG_PATH, EUSTON_ENV)
-
-hash = ErbYaml.read(MONGOID_CONFIG_PATH, EUSTON_ENV)
-
-event_connection = Mongo::Connection.new hash[:host], hash[:port], :safe => hash[:safe] #, :logger => EUSTON_LOG
-read_connection  = Mongo::Connection.new hash[:host], hash[:port], :safe => hash[:safe] #, :logger => EUSTON_LOG
-
-Euston::RabbitMq.event_store_mongodb = Mongo::DB.new(hash[:event_store_database], event_connection)
-Euston::RabbitMq.read_model_mongodb  = Mongo::DB.new(hash[:read_model_database], read_connection)
-
-Euston::EventStore::Persistence::Mongodb::Config.instance.logger = EUSTON_LOG
-Euston::EventStore::Persistence::Mongodb::Config.instance.database = Euston::CommandProcessorDaemon::Settings.mongo_db_name
-
-Euston::RabbitMq.event_store = Euston::EventStore::Persistence::Mongodb::MongoPersistenceFactory.build
-Euston::RabbitMq.event_store.init
-
-Euston::Repository.event_store = Euston::EventStore::OptimisticEventStore.new Euston::RabbitMq.event_store

data/lib/euston-daemons/command_processor_daemon/lib/components/command_handler_component.rb

@@ -1,56 +0,0 @@
-module Euston
-  module CommandProcessorDaemon
-    class CommandHandlerComponent
-      include Euston::Daemons::ComponentShutdown
-
-      attr_reader :cli_thread
-
-      def initialize daemon
-        @daemon = daemon
-      end
-
-      def start
-        handler_finder = Euston::RabbitMq::HandlerFinder.new [Euston::CommandHandler]
-        handler_finder.namespaces << Euston::RabbitMq::CommandHandlers
-        handler_finder.namespaces.push(*COMMAND_HANDLER_NAMESPACES) if Object.const_defined? 'COMMAND_HANDLER_NAMESPACES'
-        handlers = handler_finder.find
-
-        binder = Euston::RabbitMq::CommandHandlerBinder.new handlers
-        binder.ensure_bindings_exist
-
-        @cli_thread = Thread.new(@daemon, handlers) do |daemon, handlers|
-          channel_thread = Euston::Daemons::ChannelThread.new
-          channel_thread.daemon = daemon
-
-          channel_thread.run do |channel|
-            message_received = Proc.new do |message|
-              command_headers = CommandHeaders.from_hash(message[:headers]).freeze
-              command_body = message[:body].freeze
-
-              handler_type = command_headers.type.to_s.camelize.to_sym
-              handler_method_name = "__version__#{command_headers.version}"
-
-              handlers.find_all { |reference| reference.name == handler_type }.each do |reference|
-                EUSTON_LOG.debug "Delivering message to: #{reference.name}.#{handler_method_name}"
-
-                reference.handler.new.send handler_method_name, command_headers, command_body
-              end
-            end
-
-            Euston::RabbitMq::RetriableSubscription.new(channel, :command_handlers)
-              .when(:message_received => message_received)
-              .attach_queue_hook_listeners
-          end
-        end
-      end
-
-      def thread_state
-        @cli_thread.status
-      end
-
-      def stop
-        @cli_thread[:stop] = true
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-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 self
-        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}")
-        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

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

@@ -1,34 +0,0 @@
-module Euston
-  class CommandProcessorRakeTask < Euston::Daemons::RakeTask
-    attr_accessor :amqp_config_path, :command_handler_namespaces, :daemon_config_path, :mongoid_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 "Command handler namespaces: #{@command_handler_namespaces}"
-      Object.const_set :COMMAND_HANDLER_NAMESPACES, @command_handler_namespaces
-
-      EUSTON_LOG.debug "Daemon config path: #{@daemon_config_path}"
-      Object.const_set :DAEMON_CONFIG_PATH, @daemon_config_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/event_processor_daemon/config/environment.rb

@@ -1,25 +0,0 @@
-require 'jessica'
-require 'euston'
-require 'euston-eventstore'
-require 'euston-rabbitmq'
-
-require_rel '../lib'
-
-Safely::Strategy::Log.logger = EUSTON_LOG
-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)
-
-event_connection = Mongo::Connection.new hash[:host], hash[:port], :safe => hash[:safe] #, :logger => EUSTON_LOG
-read_connection  = Mongo::Connection.new hash[:host], hash[:port], :safe => hash[:safe] #, :logger => EUSTON_LOG
-
-Euston::RabbitMq.event_store_mongodb = Mongo::DB.new(hash[:event_store_database], event_connection)
-Euston::RabbitMq.read_model_mongodb  = Mongo::DB.new(hash[:read_model_database], read_connection)
-
-Mongoid.configure do |config|
-  config.master = Euston::RabbitMq.read_model_mongodb
-  config.logger = EUSTON_LOG
-end
-
-I18n.load_path += Dir[I18N_LOCALES_PATH]

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

@@ -1,58 +0,0 @@
-module Euston
-  module EventProcessorDaemon
-    class EventHandlerComponent
-      include Euston::Daemons::ComponentShutdown
-
-      attr_reader :cli_threads
-
-      def initialize daemon
-        @daemon = daemon
-        @cli_threads = {}
-      end
-
-      def start
-        handler_finder = Euston::RabbitMq::HandlerFinder.new [Euston::EventHandler]
-        handler_finder.namespaces << Euston::RabbitMq::EventHandlers
-        handler_finder.namespaces.push(*EVENT_HANDLER_NAMESPACES) if Object.const_defined? 'EVENT_HANDLER_NAMESPACES'
-        handlers = handler_finder.find
-
-        binder = Euston::RabbitMq::EventHandlerBinder.new handlers
-        binder.ensure_bindings_exist
-
-        handlers.each do |reference|
-          @cli_threads[reference.handler.to_s] = Thread.new(@daemon, reference) do |daemon, reference|
-            channel_thread = Euston::Daemons::ChannelThread.new
-            channel_thread.daemon = daemon
-
-            channel_thread.run do |channel|
-              message_received = Proc.new do |message|
-                event_headers = EventHeaders.from_hash message[:headers]
-                event_body = message[:body]
-
-                handler_method_name = "__event_handler__#{event_headers.type}__#{event_headers.version}"
-
-                EUSTON_LOG.debug "Delivering message to: #{reference.handler}.#{handler_method_name}"
-
-                reference.handler.new.send handler_method_name, event_headers.freeze, event_body.freeze
-              end
-
-              Euston::RabbitMq::RetriableSubscription.new(channel, reference.name.to_s.underscore)
-                .when(:message_received => message_received)
-                .attach_queue_hook_listeners
-            end
-          end
-        end
-      end
-
-      def thread_state
-        out = {}
-        @cli_threads.each { |k, th| out[k] = th.status }
-        out.inspect
-      end
-
-      def stop
-        @cli_threads.values.each { |th| th[:stop] = true }
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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 self
-      end
-
-      def run
-        # @bus.daemon = self
-        # @bus.start
-
-        # @servers.each do |ele|
-        #   sleep(0.5)
-        #   ele.daemon = self
-        #   ele.start
-        # end
-
-        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}"
-
-        # 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

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

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

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