rservicebus2 0.0.1

data/lib/rservicebus/message.rb

@@ -0,0 +1,78 @@
+require 'zlib'
+require 'yaml'
+require 'uuidtools'
+
+module RServiceBus
+  # This is the top level message that is passed around the bus
+  class Message
+    attr_reader :return_address, :msg_id, :remote_queue_name, :remote_host_name,
+                :last_error_source_queue, :last_error_string, :correlation_id,
+                :sendat
+
+    # Constructor
+    #
+    # @param [Object] msg The msg to be sent
+    # @param [Object] returnAddress A queue to which the destination message
+    #  handler can send replies
+    def initialize(msg, return_address, correlation_id = nil)
+      if RServiceBus.check_environment_variable('RSBMSG_COMPRESS')
+        @compressed = true
+        @_msg = Zlib::Deflate.deflate(YAML.dump(msg))
+      else
+        @compressed = false
+        @_msg = YAML.dump(msg)
+      end
+
+      @correlation_id = correlation_id
+      @return_address = return_address
+
+      @createdat = DateTime.now
+
+      @msg_id = UUIDTools::UUID.random_create
+      @error_list = []
+    end
+
+    # If an error occurs while processing the message, this method allows details of the error to held
+    # next to the msg.
+    #
+    # Error(s) are held in an array, which allows current error information to be held, while still
+    # retaining historical error messages.
+    #
+    # @param [Object] source_queue The name of the queue to which the msg should be returned
+    # @param [Object] error_string A readible version of what occured
+    def add_error_msg(source_queue, error_string)
+      @last_error_source_queue = source_queue
+      @last_error_string = error_string
+
+      @error_list << RServiceBus::ErrorMessage.new(source_queue, error_string)
+    end
+
+    def set_remote_host_name(host_name)
+      @remote_host_name = host_name
+    end
+
+    def set_remote_queue_name(queue_name)
+      @remote_queue_name = queue_name
+    end
+
+    def send_at(timestamp)
+      @send_at = timestamp
+    end
+
+    # @return [Object] The msg to be sent
+    def msg
+      if @compressed == true
+        return YAML.load(Zlib::Inflate.inflate(@_msg))
+      else
+        return YAML.load( @_msg )
+      end
+    rescue ArgumentError => e
+      raise e if e.message.index('undefined class/module ').nil?
+
+      puts e.message
+      msg_name = e.message.sub('undefined class/module ', '')
+
+      raise ClassNotFoundForMsg, msg_name
+    end
+  end
+end

data/lib/rservicebus/message/statisticoutput.rb

@@ -0,0 +1,7 @@
+module RServiceBus
+  class MessageStatisticOutputOn
+  end
+
+  class MessageStatisticOutputOff
+  end
+end

data/lib/rservicebus/message/subscription.rb

@@ -0,0 +1,10 @@
+module RServiceBus
+  # Class to hold message subscriptions
+  class MessageSubscription
+    attr_reader :event_name
+
+    def initialize(event_name)
+      @event_name = event_name
+    end
+  end
+end

data/lib/rservicebus/message/verboseoutput.rb

@@ -0,0 +1,7 @@
+module RServiceBus
+  class MessageVerboseOutputOn
+  end
+
+  class MessageVerboseOutputOff
+  end
+end

data/lib/rservicebus/monitor.rb

@@ -0,0 +1,61 @@
+module RServiceBus
+  # Monitor
+  class Monitor
+    attr_accessor :bus
+
+    # The method which actually connects to the resource.
+    def connect(_uri)
+      fail 'Method, connect, needs to be implemented for resource'
+    end
+
+    # The method which actually connects to the resource.
+    def look
+      fail 'Method, Look, needs to be implemented for the Monitor'
+    end
+
+    def _connect
+      @connection = connect(@uri)
+      @bus.log "#{self.class.name}. Connected to, #{@uri}" if
+        ENV['QUIET'].nil?
+    end
+
+    # Resources are attached resources, and can be specified using the URI
+    # syntax.
+    # @param [String] uri a location for the resource to which we will attach,
+    #  eg redis://127.0.0.1/foo
+    def initialize(bus, name, uri)
+      @bus = bus
+      new_anonymous_class = Class.new(MonitorMessage)
+      Object.const_set(name, new_anonymous_class)
+      @msg_type = Object.const_get(name)
+
+      @uri = uri
+      _connect
+    end
+
+    # A notification that allows cleanup
+    def finished
+    end
+
+    # At least called in the Host rescue block, to ensure all network links
+    #  are healthy
+    def reconnect
+      begin
+        finished
+      rescue StandardError => e
+        puts '** Monitor. An error was raised while closing connection to, ' +
+          @uri
+        puts 'Message: ' + e.message
+        puts e.backtrace
+      end
+
+      _connect
+    end
+
+    def send(payload, uri)
+      msg = @msg_type.new(payload, uri)
+
+      @bus.send(msg)
+    end
+  end
+end

data/lib/rservicebus/monitor/csvdir.rb

@@ -0,0 +1,52 @@
+require 'rservicebus/Monitor/Dir'
+require 'csv'
+
+module RServiceBus
+  # Pull files and pre-parse as csv
+  class MonitorCsvDir < MonitorDir
+    def check_payload_for_number_of_columns(payload)
+      return if @QueryStringParts.nil?
+      return unless @QueryStringParts.key?('cols')
+
+      cols = @QueryStringParts['cols'][0].to_i
+      payload.each_with_index do |row, idx|
+        if row.length != cols
+          fail "Expected number of columns, #{cols}, Actual number of columns,
+            #{row.length}, on line, #{idx}"
+        end
+      end
+    end
+
+    def check_send_hash
+      if !@QueryStringParts.nil? && @QueryStringParts.key?('hash')
+        flag = @QueryStringParts['hash'][0]
+        return flag == 'Y'
+      end
+
+      false
+    end
+
+    def process_to_hash(p)
+      headline = payload.shift
+      payload = []
+      p.each do |csvline|
+        hash = {}
+        csvline.each_with_index do |v, idx|
+          hash[headline[idx]] = v
+        end
+        payload << hash
+      end
+
+      payload
+    end
+
+    def process_content(content)
+      payload = CSV.parse(content)
+      check_payload_for_number_of_columns(payload)
+
+      payload = process_to_hash(payload) if check_send_hash
+
+      payload
+    end
+  end
+end

data/lib/rservicebus/monitor/dir.rb

@@ -0,0 +1,139 @@
+require 'cgi'
+require 'zip/zip'
+require 'zlib'
+
+module RServiceBus
+  # Monitor Directory for files
+  class MonitorDir < Monitor
+    def connect(uri)
+      # Pass the path through the Dir object to check syntax on startup
+      begin
+        input_dir = Dir.new(uri.path)
+        unless File.writable?(uri.path)
+          puts "***** Directory is not writable, #{uri.path}."
+          puts "***** Make the directory, #{uri.path}, writable and try again."
+          abort
+        end
+      rescue Errno::ENOENT
+        puts "***** Directory does not exist, #{uri.path}."
+        puts "***** Create the directory, #{uri.path}, and try again."
+        puts "***** eg, mkdir #{uri.path}"
+        abort
+      rescue Errno::ENOTDIR
+        puts "***** The specified path does not point to a directory,
+              #{uri.path}."
+        puts "***** Either repoint path to a directory, or remove, #{uri.path},
+              and create it as a directory."
+        puts "***** eg, rm #{uri.path} && mkdir #{uri.path}"
+        abort
+      end
+
+      @path = input_dir.path
+      @input_filter = []
+
+      return if uri.query.nil?
+      parts = CGI.parse(uri.query)
+      @querystringparts = parts
+      if parts.key?('archive')
+        archiveuri = URI.parse(parts['archive'][0])
+        unless File.directory?(archiveuri.path)
+          puts '***** Archive file name templating not yet supported.'
+          puts "***** Directory's only."
+          abort
+        end
+        @archivedir = archiveuri.path
+      end
+
+      return unless parts.key?('input_filter')
+
+      if parts['input_filter'].count > 1
+        puts 'Too many input_filters specified.'
+        puts '*** ZIP, or GZ are the only valid input_filters.'
+        abort
+      end
+
+      if parts['input_filter'][0] == 'ZIP'
+      elsif parts['input_filter'][0] == 'GZ'
+      elsif parts['input_filter'][0] == 'TAR'
+      else
+        puts 'Invalid input_filter specified.'
+        puts '*** ZIP, or GZ are the only valid input_filters.'
+        abort
+      end
+      @input_filter << parts['input_filter'][0]
+    end
+
+    def process_content(content)
+      content
+    end
+
+    def read_content_from_zip_file(file_path)
+      zip = Zip::ZipInputStream.open(file_path)
+      zip.get_next_entry
+      content = zip.read
+      zip.close
+
+      content
+    end
+
+    def read_content_from_gz_file(filepath)
+      gz = Zlib::GzipReader.open(filepath)
+      gz.read
+    end
+
+    def read_content_from_file(file_path)
+      content = ''
+      if @input_filter.length > 0
+        if @input_filter[0] == 'ZIP'
+          content = read_content_from_zip_file(file_path)
+        elsif @input_filter[0] == 'GZ'
+          content = read_content_from_gz_file(file_path)
+        elsif @input_filter[0] == 'TAR'
+          fail 'TAR reader not implemented'
+        end
+
+      else
+        content = IO.read(file_path)
+      end
+
+      content
+    end
+
+    def process_path(file_path)
+      content = read_content_from_file(file_path)
+      payload = process_content(content)
+
+      send(payload, URI.parse(URI.encode("file://#{file_path}")))
+      content
+    end
+
+    def look
+      file_processed = 0
+      max_files_processed = 10
+
+      file_list = Dir.glob("#{@path}/*")
+      file_list.each do |file_path|
+        RServiceBus.log "Ready to process, #{file_path}"
+        content = process_path(file_path)
+
+        unless @archivedir.nil?
+          basename = File.basename(file_path)
+          new_file_path = "#{@archivedir}/#{basename}.
+                            #{DateTime.now.strftime('%Y%m%d%H%M%S%L')}.zip"
+          RServiceBus.log "Writing to archive, #{new_file_path}"
+
+          Zip::ZipOutputStream.open(new_file_path) do |zos|
+            zos.put_next_entry(basename)
+            zos.puts content
+          end
+        end
+        File.unlink(file_path)
+
+        file_processed += 1
+        RServiceBus.log "Processed #{file_processed} of #{file_list.length}."
+        RServiceBus.log "Allow system tick #{self.class.name}"
+        break if file_processed >= max_files_processed
+      end
+    end
+  end
+end

data/lib/rservicebus/monitor/dirnotifier.rb

@@ -0,0 +1,101 @@
+require 'cgi'
+require 'fileutils'
+require 'pathname'
+
+module RServiceBus
+  # Monitor for Directory
+  class MonitorDirNotifier < Monitor
+    attr_reader :Path, :ProcessingFolder, :Filter
+    def connect(uri)
+      # Pass the path through the Dir object to check syntax on startup
+      begin
+        open_folder uri.path
+        unless File.writable?(uri.path)
+          puts "***** Directory is not writable, #{uri.path}."
+          puts "***** Make the directory, #{uri.path}, writable and try again."
+          abort
+        end
+      rescue Errno::ENOENT
+        puts "***** Directory does not exist, #{uri.path}."
+        puts "***** Create the directory, #{uri.path}, and try again."
+        puts "***** eg, mkdir #{uri.path}"
+        abort
+      rescue Errno::ENOTDIR
+        puts "***** The specified path does not point to a directory,
+              #{uri.path}."
+        puts "***** Either repoint path to a directory, or remove, #{uri.path},
+              and create it as a directory."
+        puts "***** eg, rm #{uri.path} && mkdir #{uri.path}"
+        abort
+      end
+
+      @path = uri.path
+
+      if uri.query.nil?
+        puts '***** Processing Directory is not specified.'
+        puts '***** Specify the Processing Directory as a query string in the
+              Path URI'
+        puts "***** eg, '/#{uri.path}?processing=*ProcessingDir*"
+        abort
+      else
+        parts = CGI.parse(uri.query)
+
+        if parts.key? 'processing'
+          processing_uri = URI.parse parts['processing'][0]
+          begin
+            open_folder processing_uri.path
+            unless File.writable?(processing_uri.path)
+              puts "***** Processing Directory is not writable,
+                    #{processingUri.path}."
+              puts "***** Make the directory, #{processingUri.path},
+                    writable and try again."
+              abort
+            end
+          rescue Errno::ENOENT
+            puts "***** Processing Directory does not exist,
+                  #{processingUri.path}."
+            puts "***** Create the directory, #{processingUri.path}, and try
+                  again."
+            puts "***** eg, mkdir #{processingUri.path}"
+            abort
+          rescue Errno::ENOTDIR
+            puts "***** Processing Directory does not point to a directory,
+                  #{processingUri.path}."
+            puts "***** Either repoint path to a directory, or remove,
+                  #{processingUri.path}, and create it as a directory."
+            puts "***** eg, rm #{processingUri.path} && mkdir
+                  #{processingUri.path}"
+            abort
+          end
+
+          @processing_folder = processing_uri.path
+        end
+
+        @filter = '*'
+        @filter = parts['filter'][0] if parts.key? 'filter'
+      end
+    end
+
+    def look
+      file_list = get_files
+      file_list.each do |file_path|
+        new_path = move_file(file_path, @processing_folder)
+        send(nil, URI.parse("file://#{new_path}"))
+      end
+    end
+
+    def open_folder(path)
+      Dir.new path
+    end
+
+    def move_file(src, dest)
+      FileUtils.mv(src, dest)
+      filename = Pathname.new(src).basename
+      Pathname.new(dest).join(filename)
+    end
+
+    def get_files
+      Dir.glob(Pathname.new("#{@Path}").join(@Filter) ).select { |f| File.file?(f) }
+    end
+  end
+end