rservicebus2 0.0.1

data/lib/rservicebus/saga_loader.rb

@@ -0,0 +1,118 @@
+module RServiceBus
+  # Given a directory, this class is responsible loading Sagas
+  class SagaLoader
+    attr_reader :saga_list
+
+    # 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, saga_manager)
+      @host = host
+      @saga_manager = saga_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(filePath)
+      file_path = './' + file_path unless file_path.start_with?('/')
+
+      return file_path.sub('.rb', '') if File.exist?(file_path)
+
+      abort('Filepath, ' + filePath + ", given for Saga require doesn't exist")
+    end
+
+    # Instantiate the saga named in sagaName from the file name in filePath
+    # Exceptions will be raised if encountered when loading sagas. This is a
+    # load time activity, so sagas should load correctly. As much information
+    # as possible is returned to enable the saga to be fixed, or configuration
+    # corrected.
+    # @param [String] sagaName name of the saga to instantiate
+    # @param [String] filePath the path to the file to be loaded
+    # @return [RServiceBus::Saga] the loader
+    def load_saga_from_file(saga_name, file_path)
+      require_path = get_require_path(file_path)
+
+      require require_path
+      begin
+        saga = Object.const_get(saga_name)
+      rescue StandardError => e
+        puts 'Expected class name: ' + saga_name + ', not found after require:
+          ' + require_path
+        puts '**** Check in ' + file_path + ' that the class is named : ' +
+          saga_name
+        puts '( In case its not that )'
+        raise e
+      end
+      saga
+    end
+
+    # Wrapper function
+    # @param [String] filePath
+    # @param [String] sagaName
+    # @returns [RServiceBus::Saga] saga
+    def load_saga(file_path, saga_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 'saga_name: ' + saga_name
+
+        saga = load_saga_from_file(saga_name, file_path)
+        RServiceBus.log 'Loaded Saga: ' + saga_name
+
+        @saga_manager.register_saga(saga)
+
+        @list_of_loaded_paths[file_path] = 1
+      rescue StandardError => e
+        puts 'Exception loading saga 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 "SagaLoader.getListOfFilesForDir. path: #{path},
+        list: #{list}"
+
+      list
+    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_saga_name(file_path)
+      base_name = File.basename(file_path)
+      ext_name = File.extname(base_name)
+
+      saga_name = base_name.sub(ext_name, '')
+
+      "Saga_#{saga_name}"
+    end
+
+    # Entry point for loading Sagas
+    # @param [String] base_dir directory to check - should not have trailing slash
+    def load_sagas_from_path(base_dir)
+      RServiceBus.rlog "SagaLoader.loadSagasFromPath. base_dir: #{base_dir}"
+
+      get_list_of_files_for_dir(base_dir).each do |file_path|
+        unless filePath.end_with?('.')
+          saga_name = get_saga_name(file_path)
+          load_saga(file_path, saga_name)
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/rservicebus/saga_storage.rb

@@ -0,0 +1,18 @@
+module RServiceBus
+  # Saga Storage
+  class SagaStorage
+    def self.get(uri)
+      case uri.scheme
+      when 'dir'
+        require 'rservicebus/saga_storage/dir'
+        return SagaStorageDir.new(uri)
+      when 'inmem'
+        require 'rservicebus/saga_storage/inmemory'
+        return SagaStorageInMemory.new(uri)
+      else
+        abort("Scheme, #{uri.scheme}, not recognised when configuring
+          SagaStorage, #{uri}")
+      end
+    end
+  end
+end

data/lib/rservicebus/saga_storage/dir.rb

@@ -0,0 +1,87 @@
+module RServiceBus
+
+  # Saga Storage Dir
+  class SagaStorageDir
+    def initialize(uri)
+      @saga_dir = uri.path
+
+      input_dir = Dir.new(@saga_dir)
+      unless File.writable?(@saga_dir)
+        puts "***** Directory is not writable, #{@saga_dir}."
+        puts "***** Make the directory, #{@saga_dir}, writable and try again."
+        puts '***** Or, set the Saga Directory explicitly by,
+                SAGA_URI=<dir://path/to/saga>'
+        abort
+      end
+    rescue Errno::ENOENT
+      puts "***** Directory does not exist, #{@saga_dir}."
+      puts "***** Create the directory, #{@saga_dir}, and try again."
+      puts "***** eg, mkdir #{@saga_dir}"
+      puts '***** Or, set the Saga Directory explicitly by,
+              SAGA_URI=<dir://path/to/saga>'
+      abort
+    rescue Errno::ENOTDIR
+      puts "***** The specified path does not point to a directory,
+              #{@saga_dir}."
+      puts "***** Either repoint path to a directory, or remove,
+              #{@saga_dir}, and create it as a directory."
+      puts "***** eg, rm #{@saga_dir} && mkdir #{@saga_dir}"
+      puts '***** Or, set the Saga Directory explicitly by,
+              SAGA_URI=<dir://path/to/saga>'
+      abort
+    end
+
+    # Start
+    def begin
+      @list = []
+      @deleted = []
+    end
+
+    # Set
+    def set(data)
+      path = get_path(data.correlation_id)
+      @list << Hash['path', path, 'data', data]
+    end
+
+    # Get
+    def get(correlation_id)
+      path = get_path(correlation_id)
+      data = load(path)
+      @list << Hash['path', path, 'data', data]
+
+      data
+    end
+
+    # Finish
+    def commit
+      @list.each do |e|
+        File.open(e['path'], 'w') { |f| f.write(YAML.dump(e['data'])) }
+      end
+      @deleted.each do |correlation_id|
+        File.unlink(get_path(correlation_id))
+      end
+    end
+
+    def rollback
+    end
+
+    def delete(correlation_id)
+      @deleted << correlation_id
+    end
+
+    # Detail Functions
+    def get_path(correlation_id)
+      "#{@saga_dir}/saga-#{correlation_id}"
+    end
+
+    def load(path)
+      return {} unless File.exist?(path)
+
+      content = IO.read(path)
+
+      return {} if content == ''
+
+      YAML.load(content)
+    end
+  end
+end

data/lib/rservicebus/saga_storage/inmemory.rb

@@ -0,0 +1,37 @@
+module RServiceBus
+  # Saga Storage In Memory
+  class SagaStorageInMemory
+    def initialize(_uri)
+    end
+
+    # Start
+    def begin
+      @hash = {}
+      @deleted = {}
+    end
+
+    # Set
+    def set(data)
+      @hash[data.correlation_id] = data
+    end
+
+    # Get
+    def get(correlation_id)
+      @hash[correlation_id]
+    end
+
+    # Finish
+    def commit
+      @deleted.each do |correlation_id|
+        @hash.delete(correlation_id)
+      end
+    end
+
+    def delete(correlation_id)
+      @deleted << correlation_id
+    end
+
+    def rollback
+    end
+  end
+end

data/lib/rservicebus/sendat_manager.rb

@@ -0,0 +1,33 @@
+require 'rservicebus/sendat_storage'
+
+module RServiceBus
+  # Send At Manager
+  class SendAtManager
+    def initialize(bus)
+      # Check if the SendAt Dir has been specified
+      # If it has, make sure it exists, and is writable
+
+      string = RServiceBus.get_value('SENDAT_URI')
+      string = 'file:///tmp/rservicebus-sendat' if string.nil?
+
+      uri = URI.parse(string)
+      @sendat_storage = SendAtStorage.get(uri)
+      @bus = bus
+    end
+
+    def process
+      now = DateTime.now
+      @sendat_storage.get_all.each_with_index do |row, idx|
+        next if row['timestamp'] <= now
+
+        @bus._send_needs_wrapping(row['msg'], row['queue_name'],
+                                  row['correlation_id'])
+        @sendat_storage.delete(idx)
+      end
+    end
+
+    def add(row)
+      @sendat_storage.add(row)
+    end
+  end
+end

data/lib/rservicebus/sendat_storage.rb

@@ -0,0 +1,20 @@
+
+module RServiceBus
+  # Send At Storage
+  class SendAtStorage
+    def self.get(uri)
+      case uri.scheme
+      when 'file'
+        require 'rservicebus/sendat_storage/file'
+        return SendAtStorageFile.new(uri)
+      when 'inmem'
+        require 'rservicebus/sendat_storage/inmemory'
+        return SendAtStorageInMemory.new(uri)
+      else
+        abort("Scheme, #{uri.scheme}, not recognised when configuring
+          SendAtStorage, #{uri}")
+      end
+    end
+
+  end
+end

data/lib/rservicebus/sendat_storage/file.rb

@@ -0,0 +1,37 @@
+module RServiceBus
+  # Send at storage file
+  class SendAtStorageFile
+    def initialize(uri)
+      @list = load(uri.path)
+    end
+
+    def load(path)
+      return [] unless File.exist?(path)
+
+      content = IO.read(path)
+
+      return [] if content == ''
+
+      YAML.load(content)
+    end
+
+    def add(msg)
+      @list << msg
+      save
+    end
+
+    def get_all
+      @list
+    end
+
+    def delete(idx)
+      @list.delete_at(idx)
+      save
+    end
+
+    def save
+      content = YAML.dump(@list)
+      File.open(@uri.path, 'w') { |f| f.write(YAML.dump(content)) }
+    end
+  end
+end

data/lib/rservicebus/sendat_storage/inmemory.rb

@@ -0,0 +1,20 @@
+module RServiceBus
+    # Send at storage in memory
+    class SendAtStorageInMemory
+      def initialize(_uri)
+        @list = []
+      end
+
+      def add(msg)
+        @list << msg
+      end
+
+      def all
+        @list
+      end
+
+      def delete(idx)
+        @list.delete_at(idx)
+      end
+    end
+end

data/lib/rservicebus/state_manager.rb

@@ -0,0 +1,30 @@
+require 'rservicebus/state_storage'
+
+module RServiceBus
+
+  # State Manager
+  class StateManager
+    def required
+      # Check if the State Dir has been specified
+      # If it has, make sure it exists, and is writable
+
+      string = RServiceBus.get_value('STATE_URI')
+      string = 'dir:///tmp' if string.nil?
+
+      uri = URI.parse(string)
+      @state_storage = StateStorage.get(uri)
+    end
+
+    def begin
+      @state_storage.begin unless @state_storage.nil?
+    end
+
+    def get(handler)
+      @state_storage.get(handler) unless @state_storage.nil?
+    end
+
+    def commit
+      @state_storage.commit unless @state_storage.nil?
+    end
+  end
+end

data/lib/rservicebus/state_storage.rb

@@ -0,0 +1,18 @@
+module RServiceBus
+  # State Storage
+  class StateStorage
+    def self.get(uri)
+      case uri.scheme
+      when 'dir'
+        require 'rservicebus/state_storage/dir.rb'
+        return StateStorageDir.new(uri)
+      when 'inmem'
+        require 'rservicebus/state_storage/inmemory.rb'
+        return StateStorageInMemory.new(uri)
+      else
+        abort("Scheme, #{uri.scheme}, not recognised when configuring
+          StateStorage, #{uri}")
+      end
+    end
+  end
+end

data/lib/rservicebus/state_storage/dir.rb

@@ -0,0 +1,66 @@
+module RServiceBus
+  # State Storage on the file system
+  class StateStorageDir
+    def initialize(uri)
+      @state_dir = uri.path
+
+      inputdir = Dir.new(@state_dir)
+      unless File.writable?(@state_dir)
+        puts "***** Directory is not writable, #{@state_dir}."
+        puts "***** Make the directory, #{@state_dir}, writable and try
+              again."
+        puts '***** Or, set the State Directory explicitly by,
+              STATE_URI=<dir://path/to/state>'
+        abort
+      end
+    rescue Errno::ENOENT
+      puts "***** Directory does not exist, #{@state_dir}."
+      puts "***** Create the directory, #{@state_dir}, and try again."
+      puts "***** eg, mkdir #{@state_dir}"
+      puts '***** Or, set the State Directory explicitly by,
+            STATE_URI=<dir://path/to/state>'
+      abort
+    rescue Errno::ENOTDIR
+      puts "***** The specified path does not point to a directory,
+            #{@state_dir}."
+      puts "***** Either repoint path to a directory, or remove,
+            #{@state_dir}, and create it as a directory."
+      puts "***** eg, rm #{@state_dir} && mkdir #{@state_dir}"
+      puts '***** Or, set the State Directory explicitly by,
+            STATE_URI=<dir://path/to/state>'
+      abort
+    end
+
+    def begin
+      @list = []
+    end
+
+    def get(handler)
+      path = get_path(handler)
+      hash = load(path)
+      @list << Hash['path', path, 'hash', hash]
+
+      hash
+    end
+
+    def commit
+      @list.each do |e|
+        File.open(e['path'], 'w') { |f| f.write(YAML.dump(e['hash'])) }
+      end
+    end
+
+    def get_path(handler)
+      "#{@state_dir}/#{handler.class.name}"
+    end
+
+    def load(path)
+      return {} unless File.exist?(path)
+
+      content = IO.read(path)
+
+      return {} if content == ''
+
+      YAML.load(content)
+    end
+  end
+end