rservicebus 0.0.01 → 0.0.2

data/LICENSE

@@ -1,4 +1,4 @@
-rservicebus2 is copyrighted free software by all contributors, see logs in
+RServiceBus is copyrighted free software by all contributors, see logs in
 revision control for names and email addresses of all of them.
 
 You can redistribute it and/or modify it under either the terms of the

data/README.md

@@ -0,0 +1,48 @@
+#RServiceBus
+
+A Ruby implementation of NServiceBus
+
+Where I started this project to increase my knowledge of NServiceBus, it is now
+proving to be a workable framework.
+
+
+##Principles
+	*Why are you doing it and what can go wrong
+	*Dont solve infrastructure problems with software
+		*Infrastructure in this case refers to anything not specific to the application domain
+
+##Points of view in the framework
+	* Bus
+	* Handler
+	* Client
+
+#Platform
+	* Messages
+	* MessageHandler
+	* MessageHandling
+	* Queues
+	* Transport
+	* Transactions
+
+##Message
+	* Yaml
+	* Unique Message ID's
+
+##Queues
+	* Durable
+	* Store & Forward
+	* Queues specified by config, determined by message type
+
+##Transport
+	* RabbitMQ
+
+##MessageHandler
+	* Name by convention - Handler name matchs filename
+	* Handlers are dynamically loaded
+	* If a handler fails to load, the service wont start - infrastructure problem
+
+##MessageHandling
+	* Transactions are good, use them
+	* Given transactions, the first to do on error is retry
+ 	* Once we've used up retry, put the message on an error queue to process later - it's a logic problem	
+	

data/bin/{rservicebus2 → rservicebus}

@@ -8,7 +8,8 @@ require 'rubygems'
 require 'rservicebus'
 
 def run_rservicebus()
-	RServiceBus::Host.new().run()
+	RServiceBus::Host.new()
+		.run()
 end
 
 run_rservicebus

data/lib/rservicebus.rb

@@ -1,59 +1,20 @@
-# Add the currently running directory to the start of the load path
-# $:.unshift File.dirname(__FILE__) + '/../../lib'
+require "rubygems"
+require 'beanstalk-client'
+require "yaml"
+require "uuidtools"
+require "redis"
+require "json"
+
+require "rservicebus/helper_functions"
+require "rservicebus/Agent"
+require "rservicebus/ErrorMessage"
+require "rservicebus/Message"
+require "rservicebus/Subscription"
+require "rservicebus/HandlerLoader"
+require "rservicebus/Host"
 
-# Don't buffer stdout
-$stdout.sync = true
 
-require 'rubygems'
-require 'yaml'
-require 'uuidtools'
-require 'json'
-require 'uri'
-
-require 'rservicebus/helper_functions'
-require 'rservicebus/errormessage'
-require 'rservicebus/handler_loader'
-require 'rservicebus/handler_manager'
-require 'rservicebus/appresource_configure'
-require 'rservicebus/mq'
-require 'rservicebus/host'
-require 'rservicebus/config'
-require 'rservicebus/endpointmapping'
-require 'rservicebus/stats'
-require 'rservicebus/statistic_manager'
-require 'rservicebus/audit'
-
-require 'rservicebus/message'
-require 'rservicebus/message/subscription'
-require 'rservicebus/message/statisticoutput'
-require 'rservicebus/message/verboseoutput'
-
-require 'rservicebus/usermessage/withpayload'
-
-require 'rservicebus/state_manager'
-require 'rservicebus/cron_manager'
-require 'rservicebus/circuitbreaker'
-
-require 'rservicebus/appresource'
-require 'rservicebus/resource_manager'
-
-require 'rservicebus/subscription_manager'
-require 'rservicebus/subscription_storage'
-require 'rservicebus/subscription_storage_configure'
-
-require 'rservicebus/monitor_configure'
-
-require 'rservicebus/agent'
-
-require 'rservicebus/saga_loader.rb'
-require 'rservicebus/saga/manager.rb'
-require 'rservicebus/saga/data.rb'
-require 'rservicebus/saga/base.rb'
-
-require 'rservicebus/saga_storage'
+module RServiceBus
 
-require 'rservicebus/sendat_manager'
 
-# Initial definition of the namespace
-module RServiceBus
 end

data/lib/rservicebus/Agent.rb

@@ -0,0 +1,21 @@
+module RServiceBus
+require 'beanstalk-client'
+
+class Agent
+	@beanstalk
+	
+	def initialize()
+		@beanstalk = Beanstalk::Pool.new(['localhost:11300'])
+	end
+
+	def sendMsg(messageObj, queueName, returnAddress=nil)
+		msg = RServiceBus::Message.new( messageObj, returnAddress )
+		serialized_object = YAML::dump(msg)
+
+		@beanstalk.use( queueName )
+		@beanstalk.put( serialized_object )
+	end
+
+end
+
+end

data/lib/rservicebus/Config.rb

@@ -0,0 +1,125 @@
+module RServiceBus
+
+class Config
+#host:
+##	@appName: CreateUser
+##	errorQueueName: error
+#
+
+	attr_reader :appName, :handlerPathList
+	@config
+	@appName
+	
+	@handlerPathList
+	
+	def getValue( name, default=nil )
+		if ENV[name].nil? then
+			return default
+		end
+		
+		return ENV[name]
+	end
+
+	def loadMessageEndpointMappings( host )
+		mapping = self.getValue( "RSERVICEBUS_MESSAGEENDPOINTMAPPINGS" )
+
+		messageEndpointMappings=Hash.new
+		if !mapping.nil? then
+			mapping.split( ";" ).each do |line|
+				match = line.match( /(.+):(.+)/ )
+				messageEndpointMappings[match[0]] = match[1]
+			end
+		end
+
+		host.messageEndpointMappings=messageEndpointMappings
+	end
+
+	def loadHandlerPathList(host)
+		path = self.getValue( "RSERVICEBUS_MESSAGEHANDLERPATH", "MessageHandler" )
+
+		@handlerPathList = Array.new
+		path.split( ";" ).each do |path|
+			path = path.strip.chomp( "/" )
+			@handlerPathList << path
+		end
+
+		host.handlerPathList = @handlerPathList
+	end
+
+
+	def loadHostSection( host )
+		path = self.getValue( "RSERVICEBUS_APPNAME", "RServiceBus" )
+		localQueueName = self.getValue( "RSERVICEBUS_APPNAME", "RServiceBus" )
+#		@appName = self.getValue( "host", "appName", "RServiceBus" )
+#		host.appName = @appName
+		host.localQueueName = @appName
+		host.errorQueueName = self.getValue( "host", "errorQueueName", "error" )
+		host.maxRetries = self.getValue( "host", "maxRetries", 5 )
+		host.forwardReceivedMessagesTo = self.getValue( "host", "forwardReceivedMessagesTo", nil )
+
+		self.loadHandlerPathList(host)
+	end
+
+
+	def configureLogging( host )
+		logger = Logger.new "rservicebus." + @appName
+		loggingLevel = self.getLoggingLevel()
+
+		if self.getValue( "logger", "stdout", true ) != false then
+			Outputter.stdout.level = loggingLevel
+			logger.outputters = Outputter.stdout
+		end
+
+		fileName = self.getValue( "logger", "fileName", @appName + ".log" );
+		if fileName != false then
+			file = FileOutputter.new(@appName + ".file", :filename => fileName,:trunc => false)
+			file.level = loggingLevel
+			file.formatter = PatternFormatter.new(:pattern => self.getValue( "logger", "fileFormat", "[%l] %d :: %m" ))
+			logger.add( file )
+		end
+		host.logger = logger
+	end
+
+	def processConfig( host )
+		self.loadHostSection(host)
+		self.configureLogging(host)
+		self.loadMessageEndpointMappings( host )
+
+
+		return self
+	end
+
+end
+
+
+class ConfigFromFile<Config
+
+	def getConfigurationFilePath(configFilePath)
+		configFilePath = configFilePath.nil? ? "RServiceBus.yml" : configFilePath
+		if File.exists?(configFilePath) == false then
+			puts "Config file could not be found at: " + configFilePath
+			puts "(You can specifiy a config file with: ruby RServiceBus [your config file path]"
+			abort()
+		end
+
+		return configFilePath
+	end
+
+
+	def initialize(configFilePath )
+		configFilePath = self.getConfigurationFilePath(configFilePath)
+		@config = YAML.load_file(configFilePath)
+	end
+
+end
+
+class ConfigFromYAMLObject<Config
+
+	def initialize(config )
+		@config = config
+	end
+
+end
+
+
+end

data/lib/rservicebus/ErrorMessage.rb

@@ -0,0 +1,14 @@
+module RServiceBus
+
+class ErrorMessage
+
+	attr_reader :sourceQueue, :errorMsg
+
+	def initialize( sourceQueue, errorMsg )
+		@sourceQueue=sourceQueue
+		@errorMsg=errorMsg
+	end
+
+end
+
+end

data/lib/rservicebus/HandlerLoader.rb

@@ -0,0 +1,100 @@
+module RServiceBus
+
+class HandlerLoader
+
+	attr_reader :messageName, :handler
+
+	@host
+
+	@baseDir
+	@filepath
+
+	@requirePath
+	@handlerName
+
+	@messageName
+	@handler
+
+	def initialize( baseDir, filePath, host )
+		@host = host
+
+		@baseDir = baseDir
+		@filePath = filePath
+	end
+
+	def getMessageName( baseDir, fileName )
+		name = fileName.sub( baseDir + "/", "" )
+		if name.count( "/" ) == 0 then
+			return name.match( /(.+)\./ )[1]
+		end
+				
+		if name.count( "/" ) == 1 then
+			return name.match( /\/(.+)\./ )[1]
+		end
+
+		puts "Filepath, " + fileName + ", not in the expected format."
+		puts "Expected format either,"
+		puts "MessageHandler/Hello.rb, or"
+		puts "MessageHandler/Hello/One.rb, or"
+		abort();
+	end
+
+	def getRequirePath( filePath )
+		if File.exists?( filePath ) then
+			return filePath.sub( ".rb", "")
+		end		
+		
+		if File.exists?( "./" + filePath ) then
+			return "./" + filePath.sub( ".rb", "")
+		end
+
+		abort( "Filepath, " + filePath + ", given for MessageHandler require doesn't exist" );
+	end
+
+	def parseFilepath
+		@requirePath = self.getRequirePath( @filePath )
+		@messageName = self.getMessageName( @baseDir, @filePath )
+		@handlerName = @filePath.sub( ".rb", "").sub( @baseDir, "MessageHandler" ).gsub( "/", "_" )
+
+		puts @handlerName
+		puts @filePath + ":" + @messageName + ":" + @handlerName
+	end
+
+	def loadHandlerFromFile
+		require @requirePath
+		begin
+			@handler = Object.const_get(@handlerName).new();
+		rescue Exception => e
+			puts "Expected class name: " + @handlerName + ", not found after require: " +  @requirePath
+			puts "**** Check in " + @filePath + " that the class is named : " + @handlerName
+			puts "( In case its not that )"
+			raise e
+		end
+	end
+	
+	def setBusAttributeIfRequested
+		if defined?( @handler.Bus ) then
+			@handler.Bus = @host
+			puts "Bus attribute set for: " + @handlerName
+		end
+	end
+
+	def loadHandler()
+		begin
+			self.parseFilepath
+			self.loadHandlerFromFile
+			self.setBusAttributeIfRequested
+			puts "Loaded Handler: " + @handlerName + ", for, " + @messageName
+		rescue Exception => e
+			puts "Exception loading handler from file: " + @filePath
+			puts e.message
+			puts e.backtrace[0]
+
+			abort()
+		end
+
+	end
+
+end
+
+end

data/lib/rservicebus/Host.rb

@@ -0,0 +1,340 @@
+module RServiceBus
+
+class Host
+
+	@appName
+
+	@handlerPathList
+	@handlerList
+
+	@errorQueueName
+	@maxRetries
+
+	@localQueueName
+	
+	@forwardReceivedMessagesTo
+	@forwardReceivedMessagesToQueue
+	
+	@messageEndpointMappings
+
+	@subscriptions
+	
+	@beanstalk
+
+	@verbose
+
+	def log(string, ver=false)
+		type = ver ? "VERB" : "INFO"
+		if @verbose || !ver then
+			timestamp = Time.new.strftime( "%Y-%m-%d %H:%M:%S" )
+			puts "[#{type}] #{timestamp} :: #{string}"
+		end
+	end
+
+	def getValue( name, default=nil )
+		value = ENV["#{name}"].nil? ? default : ENV["#{name}"];
+		self.log "Env value: #{name}: #{value}", true
+		return value
+	end
+
+	def loadMessageEndpointMappings()
+		mapping = self.getValue( "MESSAGE_ENDPOINT_MAPPINGS" )
+
+		messageEndpointMappings=Hash.new
+		if !mapping.nil? then
+			mapping.split( ";" ).each do |line|
+				match = line.match( /(.+):(.+)/ )
+				messageEndpointMappings[match[0]] = match[1]
+			end
+		end
+
+		@messageEndpointMappings=messageEndpointMappings
+
+		return self
+	end
+
+	def loadHandlerPathList()
+		path = self.getValue( "MSGHANDLERPATH", "MessageHandler" )
+		handlerPathList = Array.new
+		path.split( ";" ).each do |path|
+			path = path.strip.chomp( "/" )
+			handlerPathList << path
+		end
+
+		@handlerPathList = handlerPathList
+
+		return self
+	end
+
+
+	def loadHostSection()
+		@appName = self.getValue( "APPNAME", "RServiceBus" )
+		@localQueueName = @appName
+		@errorQueueName = self.getValue( "ERROR_QUEUE_NAME", "error" )
+		@maxRetries = self.getValue( "MAX_RETRIES", "5" ).to_i
+		@forwardReceivedMessagesTo = self.getValue( "FORWARD_RECEIVED_MESSAGES_TO" )
+
+		return self
+	end
+
+	def loadContracts()
+		if self.getValue( "CONTRACTS" ).nil? then
+			return self
+		end
+		
+		self.getValue( "CONTRACTS" ).split( ";" ) do |path|
+			require path
+		end
+		return self
+	end
+
+	def configureLogging()
+		@verbose = !self.getValue( "VERBOSE", nil ).nil?
+
+		return self
+	end
+
+	def configureBeanstalk
+		beanstalkHost = self.getValue( "BEANSTALK", "localhost:11300" )
+		@beanstalk = Beanstalk::Pool.new([beanstalkHost])
+
+		return self
+	end
+
+	def initialize()
+
+		self.loadHostSection()
+			.configureLogging()
+			.configureBeanstalk()
+			.loadContracts()
+			.loadMessageEndpointMappings()
+			.loadHandlerPathList()
+			.loadHandlers()
+			.loadSubscriptions()
+			.sendSubscriptions()
+
+		return self
+	end
+
+	def loadHandlersFromPath(baseDir, subDir="")
+		log "Load Message Handlers from baseDir, " + baseDir + ", subDir, " + subDir
+		log "Checking, " + baseDir, true
+
+		@handlerList = {};
+		Dir[baseDir + "/" + subDir + "*"].each do |filePath|
+			if !filePath.end_with?( "." ) then
+				log "Filepath, " + filePath, true
+
+				if File.directory?( filePath ) then
+					self.loadHandlersFromPath( filePath.sub( baseDir ) )
+				else
+					handlerLoader = HandlerLoader.new( baseDir, filePath, self )
+					handlerLoader.loadHandler
+
+					if !@handlerList.has_key?( handlerLoader.messageName ) then
+						@handlerList[handlerLoader.messageName] = Array.new
+					end
+
+					@handlerList[handlerLoader.messageName] << handlerLoader.handler;
+				end
+			end
+		end
+
+		return self
+	end
+
+	def loadHandlers()
+		log "Load Message Handlers"
+
+		@handlerPathList.each do |path|
+			self.loadHandlersFromPath(path)
+		end
+
+		return self
+	end
+
+	def sendSubscriptions
+		log "Send Subscriptions"
+		@messageEndpointMappings.each do |eventName,queueName|
+			log "Checking, " + eventName + " for Event", true
+			if eventName.end_with?( "Event" ) then
+				log eventName + ", is an event. About to send subscription to, " + queueName, true
+				self.Subscribe( eventName )
+				log "Subscribed to, " + eventName + " at, " + queueName
+			end
+		end
+
+		return self
+	end
+
+	def loadSubscriptions
+		log "Load subscriptions"
+		@subscriptions = Hash.new
+		
+		redis = Redis.new
+
+		prefix = @appName + ".Subscriptions."
+		subscriptions = redis.keys prefix + "*Event"
+
+		subscriptions.each do |subscriptionName|
+			log "Loading subscription: " + subscriptionName, true
+			eventName = subscriptionName.sub( prefix, "" )
+			@subscriptions[eventName] = Array.new			
+
+			log "Loading for event: " + eventName, true
+			subscription = redis.smembers subscriptionName
+			subscription.each do |subscriber|
+				log "Loading subscriber, " + subscriber + " for event, " + eventName, true
+				@subscriptions[eventName] << subscriber
+			end
+		end
+		
+		return self
+	end
+
+	def addSubscrption( eventName, queueName )
+		log "Adding subscrption for, " + eventName + ", to, " + queueName
+		redis = Redis.new
+		key = @appName + ".Subscriptions." + eventName
+		redis.sadd key, queueName
+
+		if @subscriptions[eventName].nil? then
+			@subscriptions[eventName] = Array.new
+		end
+		@subscriptions[eventName] << queueName
+	end
+
+	def run
+		log "Starting the Host"
+
+		log "Watching, " + @localQueueName
+		@beanstalk.watch( @localQueueName )
+		if !@forwardReceivedMessagesTo.nil? then
+			log "Forwarding all received messages to: " + @forwardReceivedMessagesTo.to_s
+		end
+
+		self.StartListeningToEndpoints
+	end
+
+
+	def StartListeningToEndpoints
+		log "Waiting for messages. To exit press CTRL+C"
+
+		loop do
+			job = @beanstalk.reserve
+			body = job.body
+			retries = @maxRetries
+			begin
+				@msg = YAML::load(body)
+				if @msg.msg.class.name == "RServiceBus::Subscription" then
+					self.addSubscrption( @msg.msg.eventName, @msg.returnAddress )
+				else
+					self.HandleMessage()
+					if !@forwardReceivedMessagesTo.nil? then
+						self._SendAlreadyWrappedAndSerialised(body,@forwardReceivedMessagesTo)
+					end
+				end
+				job.delete
+	    	rescue Exception => e
+		    	retry if (retries -= 1) > 0		    	
+
+				errorString = e.message + ". " + e.backtrace[0]
+				log errorString
+
+				@msg.addErrorMsg( @localQueueName, errorString )
+				serialized_object = YAML::dump(@msg)
+				self._SendAlreadyWrappedAndSerialised(serialized_object, @errorQueueName)
+    		end
+		end
+	end
+
+	def HandleMessage()
+		msgName = @msg.msg.class.name
+		handlerList = @handlerList[msgName]
+
+		if handlerList == nil then
+			log "No handler found for: " + msgName
+			raise "No Handler Found"
+	    else
+			log "Handler found for: " + msgName, true
+				handlerList.each do |handler|
+					begin
+			   			handler.Handle( @msg.msg )
+	   				rescue Exception => e
+						log "An error occured in Handler: " + handler.class.name
+						raise e
+			   		end
+		   		end
+    	end
+	end
+
+	def _SendAlreadyWrappedAndSerialised( serialized_object, queueName )
+		log "Bus._SendAlreadyWrappedAndSerialised", true
+
+		@beanstalk.use( queueName )
+		@beanstalk.put( serialized_object )
+	end
+
+	def _SendNeedsWrapping( msg, queueName )
+		log "Bus._SendNeedsWrapping", true
+
+		rMsg = RServiceBus::Message.new( msg, @localQueueName )
+		serialized_object = YAML::dump(rMsg)
+		log "Sending: " + msg.class.name + " to: " + queueName, true
+		self._SendAlreadyWrappedAndSerialised( serialized_object, queueName )
+	end
+
+	def Reply( msg )
+		log "Reply with: " + msg.class.name + " To: " + @msg.returnAddress, true
+
+		self._SendNeedsWrapping( msg, @msg.returnAddress )
+	end
+
+
+	def Send( msg )
+		log "Bus.Send", true
+
+
+		msgName = msg.class.name
+		if !@messageEndpointMappings.has_key?( msgName ) then
+			log "No end point mapping found for: " + msgName
+			log "**** Check in RServiceBus.yml that the section MessageEndpointMappings contains an entry named : " + msgName
+			raise "No end point mapping found for: " + msgName
+		end
+
+		queueName = @messageEndpointMappings[msgName]
+		
+		self._SendNeedsWrapping( msg, queueName )
+	end
+
+	def Publish( msg )
+		log "Bus.Publish", true
+
+
+		subscription = @subscriptions[msg.class.name]
+		if subscription.nil? then
+			log "No subscribers for event, " + msg.class.name
+			return
+		end
+
+		subscription.each do |subscriber|
+			self._SendNeedsWrapping( msg, subscriber )
+		end
+
+		
+	end
+
+	def Subscribe( eventName )
+		log "Bus.Subscribe: " + eventName, true
+
+
+		queueName = @messageEndpointMappings[eventName]
+		subscription = Subscription.new( eventName )
+
+
+		self._SendNeedsWrapping( subscription, queueName )
+	end
+
+end
+
+end