rservicebus2 0.0.1

data/lib/rservicebus/state_storage/inmemory.rb

@@ -0,0 +1,25 @@
+module RServiceBus
+  # StateStorage InMemory
+  class StateStorageInMemory
+    def initialize(_uri)
+      @hash = {}
+    end
+
+    def begin
+      @list = []
+    end
+
+    def get(handler)
+      hash = @hash[handler.class.name]
+      @list << Hash['name', handler.class.name, 'hash', hash]
+
+      hash
+    end
+
+    def commit
+      @list.each do |e|
+        @hash[e['name']] = e['hash']
+      end
+    end
+  end
+end

data/lib/rservicebus/statistic_manager.rb

@@ -0,0 +1,86 @@
+module RServiceBus
+  # Used to collect various run time stats for runtime reporting
+  class StatisticManager
+    attr_accessor :output
+
+    def initialize(host)
+      @host = host
+      @hash = {}
+
+      @total_processed = 0
+      @total_errored = 0
+      @total_sent = 0
+      @total_published = 0
+      @total_reply = 0
+
+      @total_by_message_type = {}
+
+      @output = !RServiceBus.get_value('VERBOSE', nil).nil?
+      @max_stat_output_countdown =
+        RServiceBus.get_value('STAT_OUTPUT_COUNTDOWN', '1').to_i
+      @stat_output_countdown = 0
+    end
+
+    def inc_total_processed
+      @total_processed += 1
+    end
+
+    def inc_total_errored
+      @total_errored += 1
+    end
+
+    def inc_total_sent
+      @total_sent += 1
+    end
+
+    def inc_total_published
+      @total_published += 1
+    end
+
+    def inc_total_reply
+      @total_reply += 1
+    end
+
+    def inc(key)
+      @hash[key] = 0 if @hash[key].nil?
+      @hash[key] += 1
+    end
+
+    def inc_message_type(class_name)
+      @total_by_message_type[class_name] = 0 if @total_by_message_type[class_name].nil?
+      @total_by_message_type[class_name] += 1
+    end
+
+    def get_for_reporting_2
+      return unless @written == false
+
+      @written = true
+      types = Hash.new(0)
+      ObjectSpace.each_object do |obj|
+        types[obj.class] += 1
+      end
+
+      types
+    end
+
+    def get_for_reporting_9
+      "T:#{@total_processed};" \
+      "E:#{@total_errored};" \
+      "S:#{@total_sent};" \
+      "P:#{@total_published};" \
+      "R:#{@total_reply}"
+    end
+
+    def report
+      @host.log(get_for_reporting_9) if @output
+    end
+
+    def tick
+      @stat_output_countdown -= 1
+      return unless @stat_output_countdown <= 0
+
+      report
+      @stat_output_countdown = @max_stat_output_countdown
+    end
+  end
+end

data/lib/rservicebus/stats.rb

@@ -0,0 +1,68 @@
+module RServiceBus
+  # Used to collect various run time stats for runtime reporting
+  class Stats
+    def initialize
+      @hash = {}
+
+      @total_processed = 0
+      @total_errored = 0
+      @total_sent = 0
+      @total_published = 0
+      @total_reply = 0
+
+      @total_by_message_type = {}
+
+      @written = false
+    end
+
+    def inc_total_processed
+      @total_processed += 1
+    end
+
+    def inc_total_errored
+      @total_errored += 1
+    end
+
+    def inc_total_sent
+      @total_sent += 1
+    end
+
+    def inc_total_published
+      @total_published += 1
+    end
+
+    def inc_total_reply
+      @total_reply += 1
+    end
+
+    def inc(key)
+      @hash[key] = 0 if @hash[key].nil?
+      @hash[key] += 1
+    end
+
+    def inc_message_type(class_name)
+      @total_by_message_type[class_name] = 0 if @total_by_message_type[class_name].nil?
+      @total_by_message_type[class_name] += 1
+    end
+  end
+
+  def get_for_reporting_2
+    return unless @written == false
+
+    @written = true
+    types = Hash.new(0)
+    ObjectSpace.each_object do |obj|
+      types[obj.class] += 1
+    end
+
+    types
+  end
+
+  def get_for_reporting
+    "T:#{@total_processed};
+     E:#{@total_errored};
+     S:#{@total_sent};
+     P:#{@total_published};
+     R:#{@total_reply}"
+  end
+end

data/lib/rservicebus/subscription_manager.rb

@@ -0,0 +1,31 @@
+module RServiceBus
+  # Subscription Manager
+  class SubscriptionManager
+    def initialize(subscription_storage)
+      @subscription_storage = subscription_storage
+      @subscriptions = @subscription_storage.get_all
+    end
+
+    # Get subscriptions for given eventName
+    def get(event_name)
+      subscriptions = @subscriptions[event_name]
+      if subscriptions.nil?
+        RServiceBus.log "No subscribers for event, #{event_name}"
+        RServiceBus.log "If there should be, ensure you have the appropriate evironment variable set, eg MESSAGE_ENDPOINT_MAPPINGS=#{event_name}:<Queue Name>"
+        return []
+      end
+
+      subscriptions
+    end
+
+    def add(event_name, queue_name)
+      RServiceBus.log 'Adding subscription for, ' +
+        event_name + ', to, ' + queue_name
+      @subscriptions = @subscription_storage.add(event_name, queue_name)
+    end
+
+    def remove(event_name, queue_name)
+      fail 'Method, remove, needs to be implemented for this subscription storage'
+    end
+  end
+end

data/lib/rservicebus/subscription_storage.rb

@@ -0,0 +1,39 @@
+require 'uri'
+
+module RServiceBus
+  # Base class for subscription storage
+  class SubscriptionStorage
+    # Constructor
+    # @param [String] app_name Name of the application, which is used as a
+    #  Namespace
+    # @param [String] uri a location for the resource to which we will attach,
+    #  eg redis://127.0.0.1/foo
+    def initialize(app_name, uri)
+      @app_name = app_name
+      @uri = uri
+    end
+
+    # Get a list of all subscription, as an Array
+    def get_all
+      fail 'Method, get_all, needs to be implemented for SubscriptionStorage'
+    end
+
+    # Add a new subscription
+    # @param [String] event_name Name of the event for which the subscriber
+    #  has asked for notification
+    # @param [String] queue_name the queue to which the event should be sent
+    def add(_event_name, _queue_name)
+      fail 'Method, add, needs to be implemented for this subscription storage'
+    end
+
+    # Remove an existing subscription
+    #
+    # @param [String] event_name Name of the event for which the subscriber
+    #  has asked for notification
+    # @param [String] queue_name the queue to which the event should be sent
+    def remove(_event_name, _queue_name)
+      fail 'Method, remove, needs to be implemented for this subscription
+        storage'
+    end
+  end
+end

data/lib/rservicebus/subscription_storage/file.rb

@@ -0,0 +1,42 @@
+module RServiceBus
+  # Implementation of Subscription Storage to Redis
+  class SubscriptionStorageFile < SubscriptionStorage
+    # Constructor
+    #
+    # @param [String] app_ame Name of the application, used as a Namespace
+    # @param [String] uri resource location to attach, eg redis://127.0.0.1/foo
+    def initialize(app_name, uri)
+      super(app_name, uri)
+    end
+
+    def get_all
+      RServiceBus.log 'Load subscriptions'
+      return {} unless File.exist?(@uri.path)
+
+      YAML.load(File.open(@uri.path))
+    end
+
+    def add(event_name, queue_name)
+      # s => subscriptions
+      if File.exist?(@uri.path)
+        s = YAML.load(File.open(@uri.path))
+      else
+        s = {}
+      end
+
+      s[event_name] = [] if s[event_name].nil?
+
+      s[event_name] << queue_name
+      s[event_name] = s[event_name].uniq
+
+      File.open(@uri.path, 'w') { |f| f.write(YAML.dump(s)) }
+
+      s
+    end
+
+    def remove(_event_name, _queue_name)
+      fail 'Method, remove, needs to be implemented for this
+            subscription storage'
+    end
+  end
+end

data/lib/rservicebus/subscription_storage/redis.rb

@@ -0,0 +1,69 @@
+module RServiceBus
+
+require 'redis'
+
+#Implementation of Subscription Storage to Redis
+class SubscriptionStorage_Redis<SubscriptionStorage
+
+	@redis
+
+    # Constructor
+    #
+    # @param [String] appName Name of the application, which is used as a Namespace
+    # @param [String] uri a location for the resource to which we will attach, eg redis://127.0.0.1/foo
+	def initialize( appName, uri )
+		super(appName, uri)
+        port = uri.port.nil? ? 6379 : uri.port
+		@redis = Redis.new( :host=>uri.host, :port=>port )
+	end
+
+	def getAll
+		RServiceBus.log 'Load subscriptions'
+		begin
+			content = @redis.get( @appName + '.Subscriptions')
+			if content.nil? then
+				subscriptions = Hash.new
+			else
+				subscriptions = YAML::load(content)
+			end
+			return subscriptions
+		rescue Exception => e
+			puts 'Error connecting to redis'
+			if e.message == 'Redis::CannotConnectError' ||
+					e.message == 'Redis::ECONNREFUSED' then
+				puts '***Most likely, redis is not running. Start redis, and try running this again.'
+			else
+				puts e.message
+				puts e.backtrace
+			end
+			abort()
+		end
+	end
+
+	def add( eventName, queueName )
+		content = @redis.get( @appName + '.Subscriptions')
+		if content.nil? then
+			subscriptions = Hash.new
+		else
+			subscriptions = YAML::load(content)
+		end
+
+		if subscriptions[eventName].nil? then
+			subscriptions[eventName] = Array.new
+		end
+		
+		subscriptions[eventName] << queueName
+		subscriptions[eventName] = subscriptions[eventName].uniq
+
+		@redis.set( @appName + '.Subscriptions', YAML::dump(subscriptions ) )
+
+		return subscriptions
+	end
+
+	def remove( eventName, queueName )
+		raise 'Method, remove, needs to be implemented for this subscription storage'
+	end
+
+end
+
+end

data/lib/rservicebus/subscription_storage_configure.rb

@@ -0,0 +1,19 @@
+require 'uri'
+module RServiceBus
+  # Configure SubscriptionStorage for an rservicebus host
+  class ConfigureSubscriptionStorage
+    def get(app_name, uri_string)
+      uri = URI.parse(uri_string)
+
+      case uri.scheme
+      when 'file'
+        require 'rservicebus/subscription_storage/file'
+        s = SubscriptionStorageFile.new(app_name, uri)
+      else
+        abort("Scheme, #{uri.scheme}, not recognised when configuring
+          subscription storage, #{uri_string}")
+      end
+      s
+    end
+  end
+end

data/lib/rservicebus/test.rb

@@ -0,0 +1,2 @@
+require 'rservicebus/test/bus'
+require 'rservicebus/test/redis'

data/lib/rservicebus/test/bus.rb

@@ -0,0 +1,32 @@
+module RServiceBus
+  # Test Bus
+  class TestBus
+    attr_accessor :publish_list, :send_list, :reply_list, :log_list, :sagaData
+
+    def initialize
+      @publish_list = []
+      @send_list = []
+      @reply_list = []
+      @log_list = []
+    end
+
+    def publish(msg)
+      @publish_list << msg
+    end
+
+    def send(msg)
+      @send_list << msg
+    end
+
+    def reply(msg)
+      @reply_list << msg
+    end
+
+    def log(string, verbose = false)
+      item = {}
+      item['string'] = string
+      item['verbose'] = verbose
+      @log_list << item
+    end
+  end
+end

data/lib/rservicebus/transporter.rb

@@ -0,0 +1,142 @@
+require 'beanstalk-client'
+require 'rservicebus'
+require 'net/ssh/gateway'
+
+module RServiceBus
+  class CouldNotConnectToDestination < StandardError
+  end
+
+  # TODO: Poison Message? Can I bury with timeout in beanstalk ?
+  # Needs to end up on an error queue, destination queue may be down.
+  class Transporter
+    def get_value(name, default = nil)
+      value = (ENV[name].nil? || ENV[name] == '') ? default : ENV[name]
+      RServiceBus.log "Env value: #{name}: #{value}"
+      value
+    end
+
+    def connect_to_source_beanstalk
+      source_queue_name = get_value('SOURCE_QUEUE_NAME', 'transport-out')
+      source_url = get_value('SOURCE_URL', '127.0.0.1:11300')
+      @source = Beanstalk::Pool.new([source_url])
+      @source.watch source_queue_name
+
+      RServiceBus.log "Connected to, #{source_queue_name}@#{source_url}"
+
+    rescue StandardError => e
+      puts 'Error connecting to Beanstalk'
+      puts "Host string, #{sourceUrl}"
+      if e.message == 'Beanstalk::NotConnected'
+        puts '***Most likely, beanstalk is not running. Start beanstalk, and try running this again.'
+        puts "***If you still get this error, check beanstalk is running at, #{sourceUrl}"
+      else
+        puts e.message
+        puts e.backtrace
+      end
+      abort
+    end
+
+    def disconnect
+      RServiceBus.log "Disconnect from,
+        #{@remote_user_name}@#{@remote_host_name}/#{@remote_queue_name}"
+      @gateway.shutdown! unless @gateway.nil?
+      @gateway = nil
+      @remote_host_name = nil
+
+      @destination.close unless @destination.nil?
+      @destination = nil
+
+      @remote_user_name = nil
+      @remote_queue_name = nil
+    end
+
+    def connect(remote_host_name)
+      RServiceBus.rlog "connect called, #{remote_host_name}"
+      if @gateway.nil? || remoteHostName != @remote_host_name || @destination.nil?
+        disconnect
+      end
+
+      if @gateway.nil?
+        # Get destination url from job
+        @remote_host_name = remote_host_name
+        @remote_user_name = get_value("REMOTE_USER_#{remote_host_name.upcase}")
+        if @remote_user_name.nil?
+          RServiceBus.log "**** Username not specified for Host, #{remoteHostName}"
+          RServiceBus.log "**** Add an environment variable of the form, REMOTE_USER_#{remoteHostName.upcase}=[USERNAME]"
+          abort
+        end
+
+        @local_port = get_value('LOCAL_PORT', 27018).to_i
+        RServiceBus.rlog "Local Port: #{@local_port}"
+        begin
+          RServiceBus.log "Connect SSH, #{@remote_user_name}@#{@remoteHostName}"
+          # Open port 27018 to forward to 127.0.0.11300 on the remote host
+          @gateway = Net::SSH::Gateway.new(@remote_host_name, @remote_user_name)
+          @gateway.open('127.0.0.1', 11300, @local_port)
+          RServiceBus.log "Connected to SSH, #{@remote_user_name}@#{@remote_host_name}"
+
+        rescue Errno::EADDRINUSE
+          puts "*** Local transport port in use, #{@local_port}"
+          puts "*** Change local transport port, #{@localPort}, using format, LOCAL_PORT=#{@localPort+1}"
+          abort
+        rescue Errno::EACCES
+          puts "*** Local transport port specified, #{@local_port}, needs sudo access"
+          puts '*** Change local transport port using format, LOCAL_PORT=27018'
+          abort
+        end
+
+        begin
+          destination_url = "127.0.0.1:#{@local_port}"
+          RServiceBus.rlog "Connect to Remote Beanstalk, #{destination_url}"
+          @destination = Beanstalk::Pool.new([destinationUrl])
+          RServiceBus.rlog "Connected to Remote Beanstalk, #{destination_url}"
+        rescue StandardError => e
+          if e.message == 'Beanstalk::NotConnected'
+            puts "***Could not connect to destination, check beanstalk is running at, #{destination_url}"
+            raise CouldNotConnectToDestination
+          end
+          raise
+        end
+      end
+    end
+
+    def process
+      # Get the next job from the source queue
+      job = @source.reserve @timeout
+      msg = YAML.load(job.body)
+
+      connect(msg.remote_host_name)
+
+      @remote_queue_name = msg.remote_queue_name
+      RServiceBus.rlog "Put msg, #{msg.remote_queue_name}"
+      @destination.use(msg.remote_queue_name)
+      @destination.put(job.body)
+      RServiceBus.log "Msg put, #{msg.remote_queue_name}"
+
+      unless ENV['AUDIT_QUEUE_NAME'].nil?
+        @source.use ENV['AUDIT_QUEUE_NAME']
+        @source.put job.body
+      end
+      # remove job
+      job.delete
+
+      RServiceBus.log "Job sent to, #{@remote_user_name}@#{@remote_host_name}/#{@remote_queue_name}"
+    rescue StandardError => e
+      disconnect
+      if e.message == 'TIMED_OUT'
+        RServiceBus.rlog 'No Msg'
+        return
+      end
+      raise e
+    end
+
+    def run
+      @timeout = get_value('TIMEOUT', 5)
+      connectToSourceBeanstalk
+      while true
+        process
+      end
+      disconnect_from_remote_ssh
+    end
+  end
+end