rservicebus2 0.0.1

data/lib/rservicebus/cron_manager.rb

@@ -0,0 +1,76 @@
+require 'parse-cron'
+
+module RServiceBus
+  # Globber
+  class Globber
+    def self.parse_to_regex(str)
+      escaped = Regexp.escape(str).gsub('\*', '.*?')
+      Regexp.new "^#{escaped}$", Regexp::IGNORECASE
+    end
+
+    def initialize(str)
+      @regex = self.class.parse_to_regex str
+    end
+
+    def =~(str)
+      !!(str =~ @regex)
+    end
+  end
+
+  class NoMatchingMsgForCron < StandardError
+  end
+
+  # Cron Manager
+  class CronManager
+    def get_matching_msg_names(name)
+      list = []
+      @msg_names.each do |n|
+        list << n if Globber.new(name) =~ n
+      end
+      fail NoMatchingMsgForCron, name if list.length == 0
+      list
+    end
+
+    def add_cron(name, cron_string)
+      get_matching_msg_names(name).each do |n|
+        hash = {}
+        hash['name'] = n
+        hash['last'] = Time.now
+        hash['v'] = cron_string
+        hash['cron'] = CronParser.new(cron_string)
+        hash['next'] = hash['cron'].next(Time.now)
+        @list << hash
+        @bus.log("Cron set for, #{n}, #{cron_string}, next run, #{hash['next']}")
+      end
+    end
+
+    def initialize(host, msg_names = [])
+      @bus = host
+      @msg_names = msg_names
+
+      RServiceBus.rlog 'Load Cron'
+      @list = []
+      ENV.each do |k, vs|
+        if k.start_with?('RSBCRON_')
+          add_cron(k.sub('RSBCRON_', ''), vs)
+        elsif k.start_with?('RSBCRON')
+          vs.split(';').each do |v|
+            parts = v.split(' ', 6)
+            add_cron(parts.pop, parts.join(' '))
+          end
+        end
+      end
+    end
+
+    def run
+      now = Time.now
+      @list.each_with_index do |v, idx|
+        next if now <= v['next']
+
+        RServiceBus.rlog "CronManager.Send, #{v['name']}"
+        @bus.send(RServiceBus.create_anonymous_class(v['name']))
+        @list[idx]['next'] = v['cron'].next(now)
+      end
+    end
+  end
+end

data/lib/rservicebus/endpointmapping.rb

@@ -0,0 +1,72 @@
+module RServiceBus
+  # Marshals data for message end points
+  # Expected format: <msg mame 1>:<end point 1>;<msg mame 2>:<end point 2>
+  class EndpointMapping
+    def get_value(name)
+      RServiceBus.get_value(name)
+    end
+
+    def log(string, _ver = false)
+      RServiceBus.log(string)
+    end
+
+    def configure_mapping(mapping)
+      match = mapping.match(/(.+):(.+)/)
+      if match.nil?
+        log 'Mapping string provided is invalid'
+        log "The entire mapping string is: #{mapping}"
+        log "*** Could not find ':' in mapping entry, #{line}"
+        exit
+      end
+
+      RServiceBus.rlog "EndpointMapping.configureMapping: #{match[1]}, #{match[2]}"
+      @endpoints[match[1]] = match[2]
+
+      @queue_name_list.each do |q|
+        if q != match[2] && q.downcase == match[2].downcase
+          log('*** Two queues specified with only case sensitive difference.')
+          log("*** #{q} != #{match[2]}")
+          log('*** If you meant these queues to be the same, please match case
+                and restart the bus.')
+        end
+      end
+      @queue_name_list << match[2]
+    end
+
+    def configure(local_queue_name=nil)
+      log('EndpointMapping.Configure')
+
+      @queue_name_list = []
+      @queue_name_list << local_queue_name unless local_queue_name.nil?
+
+      unless get_value('MESSAGE_ENDPOINT_MAPPING').nil?
+        log('*** MESSAGE_ENDPOINT_MAPPING environment variable was detected')
+        log("*** You may have intended MESSAGE_ENDPOINT_MAPPINGS, note the 'S'
+              on the end")
+      end
+
+      mappings = get_value('MESSAGE_ENDPOINT_MAPPINGS')
+      return self if mappings.nil?
+
+      mappings.split(';').each do |mapping|
+        configure_mapping(mapping)
+      end
+
+      self
+    end
+
+    def initialize
+      @endpoints = {}
+    end
+
+    def get(msg_name)
+      return @endpoints[msg_name] if @endpoints.key?(msg_name)
+
+      nil
+    end
+
+    def get_subscription_endpoints
+      @endpoints.keys.select { |el| el.end_with?('Event') }
+    end
+  end
+end

data/lib/rservicebus/errormessage.rb

@@ -0,0 +1,14 @@
+module RServiceBus
+
+  # Error Message
+  class ErrorMessage
+    attr_reader :occurredat, :source_queue, :error_msg
+
+    def initialize(source_queue, error_msg)
+      @occurredat = DateTime.now
+
+      @source_queue = source_queue
+      @error_msg = error_msg
+    end
+  end
+end

data/lib/rservicebus/handler_loader.rb

@@ -0,0 +1,162 @@
+module RServiceBus
+  # Given a directory, this class is responsible for finding
+  #  msgnames,
+  #  handlernames, and
+  #  loading handlers
+  class HandlerLoader
+    attr_reader :handlerList
+
+    # Constructor
+    #
+    # @param [RServiceBus::Host] host instance
+    # @param [Hash] appResources As hash[k,v] where k is the name of a
+    #  resource, and v is the resource
+    def initialize(host, handler_manager)
+      @host = host
+
+      @handler_manager = handler_manager
+
+      @list_of_loaded_paths = {}
+    end
+
+    # Cleans the given path to ensure it can be used for as a parameter for the require statement.
+    # @param [String] file_path the path to be cleaned
+    def get_require_path(file_path)
+      file_path = './' + file_path unless file_path.start_with?('/')
+
+      return file_path.sub('.rb', '') if File.exist?(file_path)
+
+      abort('Filepath, ' + file_path + ", given for MessageHandler require
+        doesn't exist")
+    end
+
+    # Instantiate the handler named in handlerName from the file name in
+    # file_path. Exceptions will be raised if encountered when loading handlers.
+    # This is a load time activity, so handlers should load correctly. As much
+    # information as possible is returned to enable the handler to be fixed,
+    # or configuration corrected.
+    # @param [String] handler_name name of the handler to instantiate
+    # @param [String] file_path the path to the file to be loaded
+    # @return [RServiceBus::Handler] the loader
+    def load_handler_from_file(handler_name, file_path)
+      require_path = get_require_path(file_path)
+
+      require require_path
+      begin
+        handler = Object.const_get(handler_name).new
+      rescue StandardError => e
+        puts 'Expected class name: ' + handler_name + ', not found after
+          require: ' + require_path
+        puts '**** Check in ' + file_path + ' that the class is named : ' +
+          handler_name
+        puts '( In case its not that )'
+        raise e
+      end
+
+      handler
+    end
+
+    # Wrapper function
+    #
+    # @param [String] file_path
+    # @param [String] handler_name
+    # @returns [RServiceBus::Handler] handler
+    def load_handler(msg_name, file_path, handler_name)
+      if @list_of_loaded_paths.key?(file_path)
+        RServiceBus.log "Not reloading, #{file_path}"
+        return
+      end
+
+      begin
+        RServiceBus.rlog 'file_path: ' + file_path
+        RServiceBus.rlog 'handler_name: ' + handler_name
+
+        handler = load_handler_from_file(handler_name, file_path)
+        RServiceBus.log 'Loaded Handler: ' + handler_name
+
+        @handler_manager.add_handler(msg_name, handler)
+
+        @list_of_loaded_paths[file_path] = 1
+      rescue StandardError => e
+        puts 'Exception loading handler from file: ' + file_path
+        puts e.message
+        puts e.backtrace[0]
+        abort
+      end
+    end
+
+    # This method is overloaded for unit tests
+    #
+    # @param [String] path directory to check
+    # @return [Array] a list of paths to files found in the given path
+    def get_list_of_files_for_dir(path)
+      list = Dir[path + '/*']
+      RServiceBus.rlog "HandlerLoader.getListOfFilesForDir. path: #{path},
+        list: #{list}"
+      list
+    end
+
+    # Multiple handlers for the same msg can be placed inside a top level
+    # directory. The msg name is than taken from the directory, and the
+    # handlers from the files inside that directory
+    #
+    # @param [String] msg_name name of message
+    # @param [String] base_dir directory to check for handlers of [msg_name]
+    def load_handlers_from_second_level_path(msg_name, base_dir)
+      get_list_of_files_for_dir(base_dir).each do |file_path|
+        next if file_path.end_with?('.')
+
+        ext_name = File.extname(file_path)
+        if !File.directory?(file_path) && ext_name == '.rb'
+          file_name = File.basename(file_path).sub('.rb', '')
+          handler_name = "MessageHandler_#{msg_name}_#{file_name}"
+
+          load_handler(msg_name, file_path, handler_name)
+        end
+      end
+
+      self
+    end
+
+    # Extract the top level dir or file name as it is the msg name
+    #
+    # @param [String] file_path path to check - this can be a directory or file
+    def get_msg_name(file_path)
+      base_name = File.basename(file_path)
+      ext_name = File.extname(base_name)
+      file_name = base_name.sub(ext_name, '')
+
+      msg_name = file_name
+    end
+
+    # Load top level handlers from the given directory
+    #
+    # @param [String] baseDir directory to check - should not have trailing slash
+    def load_handlers_from_top_level_path(base_dir)
+      RServiceBus.rlog "HandlerLoader.loadHandlersFromTopLevelPath. baseDir: #{base_dir}"
+      get_list_of_files_for_dir(base_dir).each do |file_path|
+        unless file_path.end_with?('.')
+          msg_name = get_msg_name(file_path)
+          if File.directory?(file_path)
+            load_handlers_from_second_level_path(msg_name, file_path)
+          else
+            handler_name = "MessageHandler_#{msg_name}"
+            load_handler(msg_name, file_path, handler_name)
+          end
+        end
+      end
+
+      self
+    end
+
+    # Entry point for loading handlers
+    #
+    # @param [String] baseDir directory to check - should not have trailing
+    #  slash
+    def load_handlers_from_path(base_dir)
+      load_handlers_from_top_level_path(base_dir)
+
+      self
+    end
+  end
+end

data/lib/rservicebus/handler_manager.rb

@@ -0,0 +1,131 @@
+module RServiceBus
+  # Given a directory, this class is responsible for finding
+  #  msgnames,
+  #  handlernames, and
+  #  loading handlers
+  class HandlerManager
+    # Constructor
+    #
+    # @param [RServiceBus::Host] host instance
+    # @param [Hash] app_resources As hash[k,v] where k is the name of a resource, and v is the resource
+    def initialize(host, resource_manager, state_manager)
+      @host = host
+      @resource_manager = resource_manager
+      @state_manager = state_manager
+
+      @handler_list = {}
+      @resource_list_by_handler_name = {}
+    end
+
+    # setBusAttributeIfRequested
+    #
+    # @param [RServiceBus::Handler] handler
+    def set_bus_attribute_if_requested(handler)
+      if defined?(handler.bus)
+        handler.bus = @host
+        RServiceBus.log 'Bus attribute set for: ' + handler.class.name
+      end
+
+      self
+    end
+
+    # setStateAttributeIfRequested
+    #
+    # @param [RServiceBus::Handler] handler
+    def set_state_attribute_if_requested(handler)
+      if defined?(handler.State)
+        handler.State = @state_manager.get(handler)
+        RServiceBus.log 'Bus attribute set for: ' + handler.class.name
+      end
+
+      self
+    end
+
+    # checkIfStateAttributeRequested
+    #
+    # @param [RServiceBus::Handler] handler
+    def check_if_state_attribute_requested(handler)
+      @state_manager.Required if defined?(handler.state)
+
+      self
+    end
+
+    def interrogate_handler_for_app_resources(handler)
+      RServiceBus.rlog "Checking app resources for: #{handler.class.name}"
+      RServiceBus.rlog "If your attribute is not getting set, check that it is in the 'attr_accessor' list"
+
+      @resource_list_by_handler_name[handler.class.name] = []
+      @resource_manager.get_all.each do |k, v|
+        next unless handler.class.method_defined?(k)
+
+        @resource_list_by_handler_name[handler.class.name] << k
+        RServiceBus.log "Resource attribute, #{k}, found for: " +
+          handler.class.name
+      end
+
+      self
+    end
+
+    def add_handler(msg_name, handler)
+      @handler_list[msg_name] = [] if @handler_list[msg_name].nil?
+      return unless @handler_list[msg_name].index{ |x| x.class.name == handler.class.name }.nil?
+
+      @handler_list[msg_name] << handler
+      set_bus_attribute_if_requested(handler)
+      check_if_state_attribute_requested(handler)
+      interrogate_handler_for_app_resources(handler)
+    end
+
+    # As named
+    #
+    # @param [String] msgName
+    # @param [Array] appResources A list of appResource
+    def get_list_of_resources_needed_to_process_msg(msg_name)
+      return [] if @handler_list[msg_name].nil?
+
+      list = []
+      @handler_list[msg_name].each do |handler|
+        list = list + @resource_list_by_handler_name[handler.class.name] unless @resource_list_by_handler_name[handler.class.name].nil?
+      end
+      list.uniq!
+    end
+
+    def set_resources_for_handlers_needed_to_process_msg(msg_name)
+      @handler_list[msg_name].each do |handler|
+        set_state_attribute_if_requested(handler)
+
+        next if @resource_list_by_handler_name[handler.class.name].nil?
+        @resource_list_by_handler_name[handler.class.name].each do |k|
+          handler.instance_variable_set("@#{k}", @resource_manager.get(k).get_resource)
+          RServiceBus.rlog "App resource attribute, #{k}, set for: " + handler.class.name
+        end
+      end
+    end
+
+    def get_handler_list_for_msg(msg_name)
+      return [] if @handler_list[msg_name].nil?
+
+      list = get_list_of_resources_needed_to_process_msg(msg_name)
+      set_resources_for_handlers_needed_to_process_msg(msg_name)
+
+      @handler_list[msg_name]
+    end
+
+    def can_msg_be_handled_locally(msg_name)
+      @handler_list.key?(msg_name)
+    end
+
+    def get_stats
+      list = []
+      @handler_list.each do |k, v|
+        list << v.inspect
+      end
+
+      list
+    end
+
+    def get_list_of_msg_names
+      @handler_list.keys
+    end
+  end
+end