automate-em 0.0.1

data/lib/automate-em/core/modules.rb

@@ -0,0 +1,373 @@
+module AutomateEm
+	class Modules
+		@@modules = {}	# modules (dependency_id => module class)
+		@@load_lock = Object.new.extend(MonitorMixin) #Mutex.new
+		@@loading = nil
+	
+		def self.[] (dep_id)
+			@@load_lock.mon_synchronize {
+				@@modules[dep_id]
+			}
+		end
+	
+		def self.load_module(dep)
+			@@load_lock.mon_synchronize {
+				begin
+					found = false
+					
+					Rails.configuration.automate.module_paths.each do |path|
+						if File.exists?("#{path}/#{dep.filename}")
+							load "#{path}/#{dep.filename}"
+							found = true
+							break
+						end
+					end
+					
+					if not found
+						raise "File not found!"
+					end
+					
+					@@modules[dep.id] = dep.classname.classify.constantize
+				rescue => e
+					AutomateEm.print_error(System.logger, e, {
+						:message => "device module #{dep.actual_name} error whilst loading",
+						:level => Logger::ERROR
+					})
+				end
+			
+			}
+		end
+	end
+
+	#
+	# TODO:: Consider allowing different dependancies use the same connection
+	# 	Means only the first will call received - others must use recieve blocks
+	#
+	class DeviceModule
+		@@instances = {}	# db id => @instance
+		@@dbentry = {}		# db id => db instance
+		@@devices = {}		# ip:port:udp => @instance
+		@@lookup = {}		# @instance => db id array
+		@@lookup_lock = Mutex.new
+		
+		def initialize(system, controllerDevice)
+			@@lookup_lock.synchronize {
+				if @@instances[controllerDevice.id].nil?
+					@system = system
+					@device = controllerDevice.id
+					@@dbentry[controllerDevice.id] = controllerDevice
+				end
+			}
+			instantiate_module(controllerDevice)
+		end
+		
+		
+		def unload	# should never be called on the reactor thread so no need to defer
+			
+			@instance.base.shutdown(@system)
+			
+			@@lookup_lock.synchronize {
+				db = @@lookup[@instance].delete(@device)
+				@@instances.delete(db)
+				db = @@dbentry.delete(db)
+				dev = "#{db.ip}:#{db.port}:#{db.udp}"
+				
+				if @@lookup[@instance].empty?
+					@@lookup.delete(@instance)
+					if db.udp
+						$datagramServer.remove_device(db)
+					end
+					@@devices.delete(dev)
+				end
+			}
+		end
+		
+
+		def self.lookup(instance)
+			@@lookup_lock.synchronize {
+				return @@dbentry[@@lookup[instance][0]]
+			}
+		end
+		
+		def self.instance_of(db_id)
+			@@lookup_lock.synchronize {
+				return @@instances[db_id]
+			}
+		end
+		
+		
+		attr_reader :instance
+		
+		
+		protected
+	
+	
+		def instantiate_module(controllerDevice)
+			if Modules[controllerDevice.dependency_id].nil?
+				Modules.load_module(controllerDevice.dependency)		# This is the re-load code function (live bug fixing - removing functions does not work)
+			end
+			
+			
+			baselookup = "#{controllerDevice.ip}:#{controllerDevice.port}:#{controllerDevice.udp}"
+			
+			@@lookup_lock.lock
+			if @@devices[baselookup].nil?
+				
+				#
+				# Instance of a user module
+				#
+				@instance = Modules[controllerDevice.dependency_id].new(controllerDevice.tls, controllerDevice.makebreak)
+				@instance.join_system(@system)
+				@@instances[@device] = @instance
+				@@devices[baselookup] = @instance
+				@@lookup[@instance] = [@device]
+				@@lookup_lock.unlock	#UNLOCK!! so we can lookup settings in on_load
+				
+				devBase = nil
+				
+				loaded = Proc.new {
+					EM.defer do
+						if @instance.respond_to?(:on_load)
+							begin
+								@instance.on_load
+							rescue => e
+								AutomateEm.print_error(System.logger, e, {
+									:message => "device module #{@instance.class} error whilst calling: on_load",
+									:level => Logger::ERROR
+								})
+							ensure
+								ActiveRecord::Base.clear_active_connections!
+							end
+						end
+						
+						if controllerDevice.udp
+							
+							devBase.call_connected	# UDP is stateless (always connected)
+						
+						end
+					end
+				}
+					
+				if !controllerDevice.udp
+					res = ResolverJob.new(controllerDevice.ip)
+					res.callback {|ip|
+						EM.connect ip, controllerDevice.port, Device::Base, @instance
+						loaded.call
+					}
+					res.errback {|error|
+						EM.defer do
+							System.logger.info error.message + " connecting to #{controllerDevice.dependency.actual_name} @ #{controllerDevice.ip} in #{controllerDevice.control_system.name}"
+						end
+						EM.connect "127.0.0.1", 10, Device::Base, @instance	# Connect to a nothing port until the device name is found or updated
+						loaded.call
+					}
+				else
+					#
+					# Load UDP device here
+					#	Create UDP base
+					#	Add device to server
+					# => TODO::test!!
+					#	Call connected
+					#
+					devBase = DatagramBase.new(@instance)
+					$datagramServer.add_device(controllerDevice, devBase)
+					loaded.call
+				end
+					
+					#@@devices[baselookup] = Modules.loading	# set in device_connection (see todo above)
+			else
+				#
+				# add parent may lock at this point!
+				#
+				@instance = @@devices[baselookup]
+				@@lookup[@instance] << @device
+				@@instances[@device] = @instance
+				EM.defer do
+					@instance.join_system(@system)
+				end
+				@@lookup_lock.unlock	#UNLOCK!!
+			end
+		end
+	end
+	
+	
+	class ServiceModule
+		@@instances = {}	# db id => @instance
+		@@dbentry = {}		# db id => db instance
+		@@services = {}		# uri => @instance
+		@@lookup = {}		# @instance => db id array
+		@@lookup_lock = Mutex.new
+		
+		def initialize(system, controllerService)
+			@@lookup_lock.synchronize {
+				if @@instances[controllerService.id].nil?
+					@system = system
+					@service = controllerService.id
+					@@dbentry[controllerService.id] = controllerService
+				end
+			}
+			instantiate_module(controllerService)
+		end
+		
+		
+		def unload	# should never be called on the reactor thread so no need to defer
+			
+			@instance.base.shutdown(@system)
+			
+			@@lookup_lock.synchronize {
+				db = @@lookup[@instance].delete(@service)
+				@@instances.delete(db)
+				db = @@dbentry.delete(db)
+				
+				if @@lookup[@instance].empty?
+					@@lookup.delete(@instance)
+					@@services.delete(db.uri)
+				end
+			}
+		end
+		
+
+		def self.lookup(instance)
+			@@lookup_lock.synchronize {
+				return @@dbentry[@@lookup[instance][0]]
+			}
+		end
+		
+		def self.instance_of(db_id)
+			@@lookup_lock.synchronize {
+				return @@instances[db_id]
+			}
+		end
+		
+		
+		attr_reader :instance
+		
+		
+		protected
+	
+	
+		def instantiate_module(controllerService)
+			if Modules[controllerService.dependency_id].nil?
+				Modules.load_module(controllerService.dependency)		# This is the re-load code function (live bug fixing - removing functions does not work)
+			end
+			
+			@@lookup_lock.lock
+			if @@services[controllerService.uri].nil?
+				
+				#
+				# Instance of a user module
+				#
+				@instance = Modules[controllerService.dependency_id].new
+				@instance.join_system(@system)
+				@@instances[@service] = @instance
+				@@services[controllerService.uri] = @instance
+				@@lookup[@instance] = [@service]
+				@@lookup_lock.unlock #UNLOCK
+				
+				HttpService.new(@instance, controllerService)
+				
+				
+				if @instance.respond_to?(:on_load)
+					begin
+						@instance.on_load
+					rescue => e
+						AutomateEm.print_error(System.logger, e, {
+							:message => "service module #{@instance.class} error whilst calling: on_load",
+							:level => Logger::ERROR
+						})
+					ensure
+						ActiveRecord::Base.clear_active_connections!
+					end
+				end
+			else
+				#
+				# add parent may lock at this point!
+				#
+				@instance = @@services[controllerService.uri]
+				@@lookup[@instance] << @service
+				@@instances[@service] = @instance
+				EM.defer do
+					@instance.join_system(@system)
+				end
+				@@lookup_lock.unlock #UNLOCK
+			end
+		end
+	end
+
+
+	class LogicModule
+		@@instances = {}	# id => @instance
+		@@lookup = {}		# @instance => DB Record
+		@@lookup_lock = Mutex.new
+		
+
+		def initialize(system, controllerLogic)
+			@@lookup_lock.synchronize {
+				if @@instances[controllerLogic.id].nil?
+					instantiate_module(controllerLogic, system)
+				end
+			}
+			if @instance.respond_to?(:on_load)
+				begin
+					@instance.on_load
+				rescue => e
+					AutomateEm.print_error(System.logger, e, {
+						:message => "logic module #{@instance.class} error whilst calling: on_load",
+						:level => Logger::ERROR
+					})
+				ensure
+					ActiveRecord::Base.clear_active_connections!
+				end
+			end
+		end
+		
+		def unload
+			if @instance.respond_to?(:on_unload)
+				begin
+					@instance.on_unload
+				rescue => e
+					AutomateEm.print_error(System.logger, e, {
+						:message => "logic module #{@instance.class} error whilst calling: on_unload",
+						:level => Logger::ERROR
+					})
+				ensure
+					ActiveRecord::Base.clear_active_connections!
+				end
+			end
+			
+			@instance.clear_active_timers
+			
+			@@lookup_lock.synchronize {
+				db = @@lookup.delete(@instance)
+				@@instances.delete(db.id)
+			}
+		end
+		
+		def self.lookup(instance)
+			@@lookup_lock.synchronize {
+				return @@lookup[instance]
+			}
+		end
+		
+		def self.instance_of(db_id)
+			@@lookup_lock.synchronize {
+				return @@instances[db_id]
+			}
+		end
+		
+		attr_reader :instance
+
+
+		protected
+
+
+		def instantiate_module(controllerLogic, system)
+			if Modules[controllerLogic.dependency_id].nil?
+				Modules.load_module(controllerLogic.dependency)		# This is the re-load code function (live bug fixing - removing functions does not work)
+			end
+			@instance = Modules[controllerLogic.dependency_id].new(system)
+			@@instances[controllerLogic.id] = @instance
+			@@lookup[@instance] = controllerLogic
+		end
+	end
+end

data/lib/automate-em/core/resolver_pool.rb

@@ -0,0 +1,76 @@
+module AutomateEm
+	
+	class ResolverPool
+		
+		def initialize(size = 30)
+			
+			@size = size
+			@jobs = Queue.new
+			
+			@pool = Array.new(@size) do |i|
+				
+				Thread.new do
+					#Thread.current[:id] = i
+					Thread.current.priority = Thread.current.priority - 1
+					loop do
+						begin
+							job = @jobs.pop
+							job.resolve
+						rescue => e
+							#
+							# Print error here
+							#
+						end
+					end
+				end
+				
+			end
+			
+		end
+		
+		def schedule(job)
+			@jobs << job
+		end
+	
+	end
+	
+	
+	class ResolverJob
+		
+		include EM::Deferrable
+		
+		def initialize(hostname)
+			if IPAddress.valid? hostname
+				self.succeed(hostname)
+			else
+				@hostname = hostname
+				
+				#
+				# Enter self into resolver queue
+				#
+				if EM.reactor_thread?
+					EM.defer do
+						AutomateEm.resolver.schedule(self)
+					end
+				else
+					AutomateEm.resolver.schedule(self)
+				end
+			end
+		end
+		
+		def resolve 
+			begin
+				ip = Resolv.getaddress(@hostname)
+				EM.schedule do
+					self.succeed(ip)
+				end
+			rescue => e
+				EM.schedule do
+					self.fail(e)
+				end
+			end
+		end
+		
+	end
+
+end

data/lib/automate-em/core/system.rb

@@ -0,0 +1,356 @@
+module AutomateEm
+	class System
+
+		@@systems = {:'---GOD---' => self}		# system_name => system instance
+		@@controllers = {}						# controller_id => system instance
+		@@logger = nil
+		@@communicator = AutomateEm::Communicator.new(self)
+		@@communicator.start(true)
+		@@god_lock = Mutex.new
+		
+		
+		def self.new_system(controller, log_level = Logger::INFO)
+			begin
+				if controller.class == Fixnum
+					controller = ControlSystem.find(controller)
+				elsif controller.class == String
+					controller = ControlSystem.where('name = ?', controller).first
+				end
+				
+				if controller.class != ControlSystem
+					raise 'invalid controller identifier'
+				end
+			
+				@@god_lock.lock
+				if @@controllers[controller.id].nil?
+					@@god_lock.unlock
+					sys = System.new(controller, log_level)
+					if controller.active
+						begin
+							sys.start(true)			# as this is loading the first time we ignore controller active
+						rescue => e
+							AutomateEm.print_error(@@logger, e, {
+								:message => "Error starting system in new_system, stopping..",
+								:level => Logger::ERROR
+							})
+							begin
+								sys.stop
+								EM.schedule do
+									EM.add_timer(60) do # Attempt a single restart
+										EM.defer do
+											begin
+												sys.start(true)
+											rescue => e
+												begin
+													AutomateEm.print_error(@@logger, e, {
+														:message => "Second start attempt failed..",
+														:level => Logger::ERROR
+													})
+													sys.stop
+												rescue
+												end
+											end
+										end
+									end
+								end
+							rescue => e
+								AutomateEm.print_error(@@logger, e, {
+									:message => "Error stopping system after problems starting..",
+									:level => Logger::ERROR
+								})
+							end
+						end
+					end
+				else
+					@@god_lock.unlock
+				end
+			ensure
+				ActiveRecord::Base.clear_active_connections!	# Clear any unused connections
+			end
+		end
+		
+		
+		#
+		# Reloads a dependency live
+		#	This is the re-load code function (live bug fixing - removing functions does not work)
+		#
+		def self.reload(dep)
+			System.logger.info "reloading dependency: #{dep}"
+			
+			dep = Dependency.find(dep)
+			Modules.load_module(dep)
+			
+			updated = {}
+			dep.devices.select('id').each do |dev|
+				begin
+					inst = DeviceModule.instance_of(dev.id)
+					inst.on_update if (!!!updated[inst]) && inst.respond_to?(:on_update)
+				ensure
+					updated[inst] = true
+				end
+			end
+			
+			updated = {}
+			dep.logics.select('id').each do |log|
+				begin
+					inst = LogicModule.instance_of(log.id)
+					inst.on_update if (!!!updated[inst]) && inst.respond_to?(:on_update)
+				ensure
+					updated[inst] = true
+				end
+			end
+			
+			ActiveRecord::Base.clear_active_connections!	# Clear any unused connections
+		end
+		
+		#
+		# Allows for system updates on the fly
+		#	Dangerous (Could be used to add on the fly interfaces)
+		#
+		def self.force_load_file(path)
+			load path if File.exists?(path) && File.extname(path) == '.rb'
+		end
+		
+		
+		#
+		# System Logger
+		#
+		def self.logger
+			@@logger
+		end
+		
+		def self.logger=(log)
+			@@logger = log
+		end
+		
+		#def self.controllers
+		#	@@controllers
+		#end
+	
+		#def self.systems
+		#	@@systems
+		#end
+		
+		def self.communicator
+			@@communicator
+		end
+		
+		def self.[] (system)
+			system = system.to_sym if system.class == String
+			@@god_lock.synchronize {
+				@@systems[system]
+			}
+		end
+		
+		
+		
+		#
+		# For access via communicator as a super user
+		#
+		def self.modules
+			self
+		end
+		def self.instance
+			self
+		end
+		def instance
+			self
+		end
+		# ---------------------------------
+		
+		
+	
+		#
+		#	Module accessor
+		#
+		def [] (mod)
+			mod = mod.to_sym if mod.class == String
+			@modules[mod].instance
+		end
+
+		attr_reader :modules
+		attr_reader :communicator
+		attr_reader :controller
+		attr_accessor :logger
+		
+		
+		
+		#
+		# Starts the control system if not running
+		#
+		def start(force = false)
+			System.logger.info "starting #{@controller.name}"
+			@sys_lock.synchronize {
+				@@god_lock.synchronize {
+					@@systems.delete(@controller.name.to_sym)
+					@controller.reload #(:lock => true)
+					@@systems[@controller.name.to_sym] = self
+				}
+				
+				if !@controller.active || force
+					if @logger.nil?
+						if Rails.env.production?
+							@logger = Logger.new("#{ROOT_DIR}/interface/log/system_#{@controller.id}.log", 10, 4194304)
+						else
+							@logger = Logger.new(STDOUT)
+						end
+						@logger.formatter = proc { |severity, datetime, progname, msg|
+							"#{datetime.strftime("%d/%m/%Y @ %I:%M%p")} #{severity}: #{@controller.name} - #{msg}\n"
+						}
+					end
+					
+					@controller.devices.includes(:dependency).each do |device|
+						load_hooks(device, DeviceModule.new(self, device))
+					end
+					
+					@controller.services.includes(:dependency).each do |service|
+						load_hooks(service, ServiceModule.new(self, service))
+					end
+				
+					@controller.logics.includes(:dependency).each do |logic|
+						load_hooks(logic, LogicModule.new(self, logic))
+					end
+				end
+				
+				@controller.active = true
+				@controller.save
+				
+				@communicator.start
+			}
+		end
+		
+		#
+		# Stops the current control system
+		# 	Loops through the module instances.
+		#
+		def stop
+			System.logger.info "stopping #{@controller.name}"
+			@sys_lock.synchronize {
+				stop_nolock
+			}
+		end
+		
+		#
+		# Unload and then destroy self
+		#
+		def delete
+			System.logger.info "deleting #{@controller.name}"
+			@sys_lock.synchronize {
+				stop_nolock
+				
+				@@god_lock.synchronize {
+					@@systems.delete(@controller.name.to_sym)
+					@@controllers.delete(@controller.id)
+				}
+				
+				begin
+					@controller.destroy!
+				rescue
+					# Controller may already be deleted
+				end
+				@modules = nil
+			}
+		end
+		
+		
+		#
+		# Log level changing on the fly
+		#
+		def log_level(level)
+			@sys_lock.synchronize {
+				@log_level = AutomateEm::get_log_level(level)
+				if @controller.active
+					@logger.level = @log_level
+				end
+			}
+		end
+		
+	
+		protected
+		
+		
+		def stop_nolock
+			
+			begin
+				@@god_lock.synchronize {
+					@@systems.delete(@controller.name.to_sym)
+					@controller.reload(:lock => true)
+					@@systems[@controller.name.to_sym] = self
+				}
+			rescue
+				# Assume controller may have been deleted
+			end
+			
+			if @controller.active
+				@communicator.shutdown
+				modules_unloaded = {}
+				@modules.each_value do |mod|
+					
+					if modules_unloaded[mod] == nil
+						modules_unloaded[mod] = :unloaded
+						mod.unload
+					end
+					
+				end
+				@modules = {}	# Modules no longer referenced. Cleanup time!
+				@logger.close if Rails.env.production?
+				@logger = nil
+			end
+			
+			@controller.active = false
+			begin
+				@controller.save
+			rescue
+				# Assume controller may have been deleted
+			end
+		end
+	
+	
+		def load_hooks(device, mod)
+			module_name = device.dependency.module_name
+			count = 2	# 2 is correct
+			
+			#
+			# Loads the modules and auto-names them (display_1, display_2)
+			#	The first module of a type has two names (display and display_1 for example)
+			#	Load order is controlled by the control_system model based on the ordinal
+			#
+			if not @modules[module_name.to_sym].nil?
+				while @modules["#{module_name}_#{count}".to_sym].present?
+					count += 1
+				end
+				module_name = "#{module_name}_#{count}"
+			else
+				@modules["#{module_name}_1".to_sym] = mod
+			end
+			@modules[module_name.to_sym] = mod
+			
+			#
+			# Allow for system specific custom names
+			#
+			if !device.custom_name.nil?
+				@modules[device.custom_name.to_sym] = mod
+			end
+		end
+		
+		
+		def initialize(controller, log_level)
+			
+			
+			@modules = {}	# controller modules	:name => module instance (device or logic)
+			@communicator = AutomateEm::Communicator.new(self)
+			@log_level = log_level
+			@controller = controller
+			@sys_lock = Mutex.new
+			
+			
+			#
+			# Setup the systems links
+			#
+			@@god_lock.synchronize {
+				@@systems[@controller.name.to_sym] = self	# it may not be started
+				@@controllers[@controller.id] = self
+			}
+		end
+	end
+end