automate-em 0.0.1

data/app/models/user_zone.rb

@@ -0,0 +1,10 @@
+class UserZone < ActiveRecord::Base
+	belongs_to	:zone
+	belongs_to	:group
+	
+	
+	protected
+	
+	
+	validates_presence_of :group, :zone
+end

data/app/models/zone.rb

@@ -0,0 +1,16 @@
+class Zone < ActiveRecord::Base
+	has_many	:user_zones
+	has_many	:controller_zones
+	
+	has_many	:groups, :through => :user_zones
+	has_many	:control_systems, :through => :controller_zones
+	
+	has_many :settings, :as => :object,	:dependent => :destroy
+	
+	
+	protected
+	
+	
+	validates_presence_of :name
+	validates_uniqueness_of :name
+end

data/db/migrate/20111001022500_init.rb

@@ -0,0 +1,147 @@
+class Init < ActiveRecord::Migration
+	def change
+		#
+		# These represent individual systems
+		#
+		create_table :control_systems do |t|
+			t.string	:name,		:allow_null => false
+			t.text		:description
+			t.boolean	:active,	:default => true,	:allow_null => false
+			
+			t.timestamps
+		end
+		
+		#
+		# Describe modules that can be loaded and exist on the system
+		#
+		create_table :dependencies do |t|
+			t.references	:dependency
+			
+			t.string		:classname,		:allow_null => false
+			t.string		:filename,		:allow_null => false
+			
+			t.string		:module_name,	:allow_null => false	# Type name (Projector)
+			t.string		:actual_name,	:allow_null => false	# Real name (All NEC Projectors)
+			t.text			:description
+			
+			t.datetime		:version_loaded
+			
+			t.timestamps
+		end
+		
+		#
+		# Device and Logic instances
+		# => Priority provides load order (high priorities load first)
+		#
+		create_table :controller_devices do |t|
+			t.references	:control_system,:allow_null => false
+			t.references	:dependency,	:allow_null => false
+
+			t.string	:ip,	:allow_null => false
+			t.integer	:port,:allow_null => false
+			
+			t.boolean	:tls,	:default => false,	:allow_null => false
+			t.boolean	:udp,	:default => false,	:allow_null => false
+			
+			t.integer	:priority,	:default => 0
+			
+			t.string	:custom_name	# projector_left
+			
+			t.timestamps
+		end
+		
+		create_table :controller_logics do |t|
+			t.references	:control_system,:allow_null => false
+			t.references	:dependency,	:allow_null => false
+			
+			t.integer		:priority,	:default => 0
+			
+			t.string		:custom_name
+			
+			t.timestamps
+		end
+		
+		#
+		# Settings relating to Dependencies, Devices instances, Interfaces and Interface Instances
+		#
+		create_table :settings do |t|
+			t.references :object, :polymorphic => true		
+
+			t.string	:name,			:allow_null => false
+			t.text		:description
+			
+			t.integer	:value_type,	:allow_null => false
+			
+			t.float		:float_value
+			t.integer	:integer_value	# doubles as boolean (type -1)
+			t.text		:text_value
+			t.datetime	:datetime_value
+			
+			t.timestamps
+		end
+		
+		#
+		# Describes the interfaces avaliable
+		#
+		#create_table :guis do |t|
+		#	t.string	:name,	:allow_null => false
+		#	t.text		:description
+			
+		#	t.datetime	:version		# Cache update indicator
+		#	t.text		:render_path	# Path of file to render
+			
+			# Location information here for
+			# access if the device is local
+			
+		#	t.timestamps
+		#end
+		
+		#
+		# Zones can be used to classify the various control systems
+		# => General Type (meeting room, seminar room)
+		# => Floor, Building, Campus
+		# This allows fine grained access control for users
+		#
+		create_table :zones do |t|
+			t.string	:name,	:allow_null => false
+			t.text		:description
+			
+			t.timestamps
+		end
+		
+		create_table :user_zones do |t|
+			t.references :group
+			t.references :zone
+			
+			t.integer	:privilege_map	# if not null overrides user default privilege map (user zones OR'ed)
+			
+			t.timestamps
+		end
+		
+		create_table :controller_zones do |t|
+			t.references :control_system
+			t.references :zone
+			
+			t.timestamps
+		end
+		
+		#
+		# Trusted devices
+		# => System 0 cannot trust any interface as does not have an explicit controller id
+		#
+		create_table :trusted_devices do |t|
+			t.references	:user,			:allow_null => false
+			t.references	:control_system,:allow_null => false
+			
+			t.string	:description,		:allow_null => false
+			t.text		:notes
+			
+			t.string	:one_time_key
+			t.string	:next_key
+			t.datetime	:expires			# Expire devices (staff member leaving etc)
+			t.datetime	:last_authenticated	# Cache update indicator
+			
+			t.timestamps
+		end
+	end
+end

data/db/migrate/20111017213801_one_time_key.rb

@@ -0,0 +1,9 @@
+class OneTimeKey < ActiveRecord::Migration
+	def up
+		rename_column	:trusted_devices, :description, :reason
+	end
+
+	def down
+		rename_column	:trusted_devices, :reason, :description
+	end
+end

data/db/migrate/20111021071632_encrypt_setting.rb

@@ -0,0 +1,9 @@
+class EncryptSetting < ActiveRecord::Migration
+	def up
+		add_column		:settings, :encrypt_setting, :boolean, :default => false
+	end
+
+	def down
+		remove_column	:settings, :encrypt_setting
+	end
+end

data/db/migrate/20111110075444_servers.rb

@@ -0,0 +1,15 @@
+class Servers < ActiveRecord::Migration
+	def up
+		create_table :servers do |t|
+			t.boolean	:online,	:allow_null => false, :default => true
+			
+			t.string	:hostname,	:allow_null => false
+			
+			t.text		:notes
+		end
+	end
+
+	def down
+		#drop table
+	end
+end

data/db/migrate/20111114074538_default_port.rb

@@ -0,0 +1,9 @@
+class DefaultPort < ActiveRecord::Migration
+	def up
+  		add_column		:dependencies, :default_port, :integer
+	end
+
+	def down
+		remove_column	:dependencies, :default_port
+	end
+end

data/db/migrate/20111122073055_makebreak.rb

@@ -0,0 +1,9 @@
+class Makebreak < ActiveRecord::Migration
+	def up
+  		add_column		:controller_devices, :makebreak, :boolean, :default => false,	:allow_null => false
+	end
+
+	def down
+		remove_column	:controller_devices, :makebreak
+	end
+end

data/db/migrate/20111211062846_create_controller_http_services.rb

@@ -0,0 +1,18 @@
+class CreateControllerHttpServices < ActiveRecord::Migration
+	def change
+		create_table :controller_http_services do |t|
+			
+			t.references	:control_system,:allow_null => false
+			t.references	:dependency,	:allow_null => false
+
+			t.string	:uri,	:allow_null => false
+			
+			t.integer	:priority,	:default => 0,	:allow_null => false
+			t.string	:custom_name	# projector_left
+			
+			t.timestamps
+		end
+		
+		add_column		:dependencies, :default_uri, :string
+	end
+end

data/lib/automate-em.rb

@@ -0,0 +1,155 @@
+require "automate-em/engine"
+
+#
+# TODO:: Use autoload here to avoid loading these unless control is running!
+#
+
+#
+# STD LIB
+#
+require 'observer'
+require 'yaml'
+require 'thread'
+require 'monitor'
+require 'Socket'	# for DNS lookups 
+require 'Logger'
+
+
+#
+# Gems
+#
+require 'rubygems'
+require 'eventmachine'
+require 'em-priority-queue'
+require 'em-http'
+require 'rufus/scheduler'
+require 'ipaddress'
+
+
+#
+# Library Files
+#
+require 'automate-em/constants.rb'
+require 'automate-em/utilities.rb'
+require 'automate-em/status.rb'
+
+require 'automate-em/core/resolver_pool.rb'
+require 'automate-em/core/modules.rb'
+require 'automate-em/core/communicator.rb'
+require 'automate-em/core/system.rb'
+
+require 'automate-em/device/device.rb'
+require 'automate-em/device/device_connection.rb'
+require 'automate-em/device/datagram_server.rb'
+require 'automate-em/device/tcp_control.rb'
+
+require 'automate-em/service/service.rb'
+require 'automate-em/service/http_service.rb'
+
+require 'automate-em/logic/logic.rb'
+
+require 'automate-em/interfaces/html5.rb'
+
+
+module AutomateEm
+	
+	
+	def self.load_paths= (paths)
+		@@load_paths = ([] << paths) # TODO:: this doesn't work
+	end
+	
+	
+	def self.scheduler
+		@@scheduler
+	end
+	
+	
+	def self.resolver
+		@@resolver
+	end
+	
+	
+	def self.get_log_level(level)
+		if level.nil?
+			return Logger::INFO
+		else
+			return case level.downcase.to_sym
+				when :debug
+					Logger::DEBUG
+				when :warn
+					Logger::WARN
+				when :error
+					Logger::ERROR
+				else
+					Logger::INFO
+			end
+		end
+	end
+	
+	
+	def self.boot
+		
+		#
+		# System level logger
+		#
+		if Rails.env.production?
+			System.logger = Logger.new(Rails.root.join('log/system.log').to_s, 10, 4194304)
+		else
+			System.logger = Logger.new(STDOUT)
+		end
+		System.logger.formatter = proc { |severity, datetime, progname, msg|
+			"#{datetime.strftime("%d/%m/%Y @ %I:%M%p")} #{severity}: #{System} - #{msg}\n"
+		}
+		
+		@@resolver = ResolverPool.new
+		
+		EventMachine.run do
+			#
+			# Enable the scheduling system
+			#
+			@@scheduler = Rufus::Scheduler.start_new
+			
+			EM.defer do
+				System.logger.debug "Started with #{EM.get_max_timers} timers avaliable"
+				System.logger.debug "Started with #{EM.threadpool_size} threads in pool"
+			end
+			
+			#
+			# Start the UDP server
+			#
+			EM.open_datagram_socket "0.0.0.0", 0, DatagramServer
+			
+			#
+			# Load the system based on the database
+			#
+			ControlSystem.all.each do |controller|
+				EM.defer do
+					begin
+						System.logger.debug "Booting #{controller.name}"
+						System.new_system(controller, Rails.configuration.automate.log_level)
+					rescue => e
+						AutomateEm.print_error(AutomateEm::System.logger, e, {
+							:message => "Error during boot",
+							:level => Logger::FATAL
+						})
+						EventMachine::stop_event_loop
+					end
+				end
+			end
+			
+			#
+			# Emit connection counts for logging
+			#
+			@@scheduler.every '10m' do
+				System.logger.info "There are #{EM.connection_count} connections to this server"
+			end
+			
+			#
+			# We should AutoLoad the interfaces as plugins rather than having them in the core
+			#
+			EM.add_timer(20) do
+				System.start_websockets
+			end
+		end
+	end
+end

data/lib/automate-em/constants.rb

@@ -0,0 +1,6 @@
+module AutomateEm
+	module Constants
+		On = true
+		Off = false
+	end
+end

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

@@ -0,0 +1,318 @@
+#
+# There should be one communicator per system that handles the interface interfaces
+#	This will pass on registered status requirements and call functions as requested
+#
+#	Interfaces will have to have a base class that abstracts the event machine code so that
+#	nothing runs on the reactor thread.
+#
+module AutomateEm
+class Communicator
+
+	def initialize(system)
+		@system = system
+		
+		@command_lock = Mutex.new
+		@status_lock = Mutex.new
+		
+		@status_register = {}
+		@connected_interfaces = {}
+		
+		@shutdown = true
+	end
+	
+
+	def logger
+		@system.logger
+	end
+	
+	
+	def shutdown
+		@status_lock.synchronize {
+			@shutdown = true
+			@system.modules.each_value do |mod|
+				mod.instance.delete_observer(self)
+			end
+			@status_register = {}			
+			@connected_interfaces.each_key do |soc|
+				soc.shutdown
+			end
+		}
+		logger.debug "-- Communicator shutdown"
+	end
+	
+	def start(nolog = false)			# Logging isn't active for the very first of these
+		@status_lock.synchronize {
+			@shutdown = false
+		}
+		logger.debug "-- Communicator started" unless nolog
+	end
+
+	
+	#
+	# Systems avaliable to this user
+	#
+	def self.system_list(user)
+		response = {:ids => [], :names => []}
+		
+		if user.class == User
+			user.control_systems.select('control_systems.id, control_systems.name').each do |controller|
+				if !!System[controller.name.to_sym]
+					response[:ids] << controller.id
+					response[:names] << controller.name
+				end
+			end 	# We ignore token requests here as they should know the system they can connect to
+		end
+		return response
+	end
+	
+	#
+	# Set the system to communicate with
+	#	Up to interfaces to maintain stability here (They should deal with errors)
+	#
+	def self.select(user, interface, system)
+		System.logger.debug "-- Interface #{interface.class} attempting to select system #{system}"
+		if system == 0
+			return nil unless user[:system_admin]
+			System.communicator.attach(interface)
+		else
+			sys = nil
+			
+			if user.class == User
+				sys = user.control_systems.select('control_systems.name').where('control_systems.id = ? AND control_systems.active = ?', system.to_i, true).first
+				
+			elsif user.class == TrustedDevice && user.control_system_id == system.to_i
+				sys = User.find(user.user_id).control_systems.select('control_systems.name, control_systems.active').where('control_systems.id = ?', system.to_i).first
+				if sys.nil?
+					#
+					# Kill comms, this key is not valid
+					#	Invalidate key
+					#
+					user.expires = Time.now
+					user.save
+					interface.shutdown
+					return nil
+				elsif sys.active == false
+					#
+					# System offline... Disconnect
+					#
+					return false
+				end
+			end
+			
+			system = sys.nil? ? nil : sys.name.to_sym
+			if System[system].nil?
+				interface.shutdown	#kill comms
+				return nil
+			end
+			
+			System.logger.debug "-- Interface #{interface.class} selected system #{system}"
+			return System[system].communicator.attach(interface)
+		end
+	end
+
+
+
+
+	#
+	# Keep track of connected systems
+	#
+	def disconnected(interface)
+		@status_lock.synchronize {
+			status_array = @connected_interfaces.delete(interface)
+			status_array.each do |status_hash|
+				status_hash.delete(interface)
+			end
+			#
+			# TODO::Refactor required
+			#	This still isn't perfect as we could be observing modules we are not using...
+			#
+		}
+		logger.debug "-- Interface #{interface.class} disconnected" unless logger.nil?
+	end
+
+
+	#
+	# Keep track of status events
+	#
+	def register(interface, mod, status, &block)
+		mod_sym = mod.class == String ? mod.to_sym : mod	# remember the symbol used by the interface to reference this module
+		status = status.to_sym if status.class == String
+		
+		if @system.modules[mod_sym].present?
+			mod = @system.modules[mod_sym].instance	# most efficient
+	
+			theVal = nil
+			@status_lock.synchronize {
+				@status_register[mod] ||= {}
+				@status_register[mod][status] ||= {}
+				@status_register[mod][status][interface] = mod_sym
+				@connected_interfaces[interface] << @status_register[mod][status] unless @connected_interfaces[interface].nil?
+				theVal = mod[status]
+			}
+			
+			mod.add_observer(self)
+			logger.debug "-- Interface #{interface.class} registered #{mod_sym}:#{status}"
+			
+			#
+			# Send the status to this requestor!
+			#	This is the same as in update
+			#
+			if !theVal.nil?
+				begin
+					function = "#{mod_sym.to_s.downcase}_#{status}_changed".to_sym
+					
+					if interface.respond_to?(function)
+						interface.__send__(function, theVal)
+					else
+						interface.notify(mod_sym, status, theVal)
+					end
+				rescue => e
+					AutomateEm.print_error(logger, e, {
+						:message => "in communicator.rb, register : bad interface or user module code",
+						:level => Logger::ERROR
+					})
+				end
+			end
+		else
+			logger.warn "in communicator.rb, register : #{interface.class} called register on a bad module name"
+			block.call() unless block.nil?	# Block will inform of any errors
+		end
+	rescue => e
+		begin
+			AutomateEm.print_error(logger, e, {
+				:message => "in communicator.rb, register : #{interface.class} failed to register #{mod.inspect}.#{status.inspect}",
+				:level => Logger::ERROR
+			})
+			block.call() unless block.nil?	# Block will inform of any errors
+		rescue => x
+			AutomateEm.print_error(logger, x, {
+				:message => "in communicator.rb, register : #{interface.class} provided a bad block",
+				:level => Logger::WARN
+			})
+		end
+	ensure
+		ActiveRecord::Base.clear_active_connections!
+	end
+
+	def unregister(interface, mod, status, &block)
+		mod_sym = mod.to_sym if mod.class == String
+		status = status.to_sym if status.class == String
+		
+		mod = @system.modules[mod_sym].instance
+		logger.debug "Interface #{interface.class} unregistered #{mod_sym}:#{status}"
+
+		@status_lock.synchronize {
+			@status_register[mod] ||= {}
+			@status_register[mod][status] ||= {}
+			@status_register[mod][status].delete(interface)
+			@connected_interfaces[interface].delete(@status_register[mod][status]) unless @connected_interfaces[interface].nil?
+
+			#
+			# TODO:: deleteing the observer will delete all status updates
+			#	This needs to be more selective.
+			#	We only delete the observer if all the mod[status]'s are empty
+			#
+			#if @status_register[mod][status].empty?
+			#	mod.delete_observer(self)
+			#end
+		}
+	rescue => e
+		logger.warn "in communicator.rb, unregister : #{interface.class} called unregister when it was not needed"
+		#logger.warn e.message
+		#logger.warn e.backtrace
+		begin
+			block.call() if !block.nil?	# Block will inform of any errors
+		rescue => x
+			AutomateEm.print_error(logger, x, {
+				:message => "in communicator.rb, unregister : #{interface.class} provided a bad block",
+				:level => Logger::WARN
+			})
+		end
+	end
+
+	def update(mod, status, data)
+		@status_lock.synchronize {
+			return if @status_register[mod].nil? || @status_register[mod][status].nil?
+		
+			#
+			# Interfaces should implement the notify function
+			#	Or a function for that particular event
+			#
+			@status_register[mod][status].each_pair do |interface, mod|
+				EM.defer do	# to avoid deadlock
+					begin
+						function = "#{mod.to_s.downcase}_#{status}_changed".to_sym
+						if interface.respond_to?(function)				# Can provide a function to deal with status updates
+							interface.__send__(function, data)
+						else
+							interface.notify(mod, status, data)
+						end
+					rescue => e
+						AutomateEm.print_error(logger, e, {
+							:message => "in communicator.rb, update : bad interface or user module code",
+							:level => Logger::ERROR
+						})
+					ensure
+						ActiveRecord::Base.clear_active_connections!
+					end
+				end
+			end
+		}
+	rescue => e
+		AutomateEm.print_error(logger, e, {
+			:message => "in communicator.rb, update : This should never happen",
+			:level => Logger::ERROR
+		})
+	end
+	
+	#
+	# Pass commands to the selected system
+	#
+	def send_command(mod, command, *args, &block)
+		#
+		# Accept String, argument array
+		#	String
+		#
+		mod = mod.to_sym if mod.class == String
+		logger.debug "-- Command requested #{mod}.#{command}(#{args})"
+		
+		begin
+			@command_lock.synchronize {
+				@system.modules[mod].instance.public_send(command, *args)	# Not send string however call function command
+			}
+		rescue => e
+			AutomateEm.print_error(logger, e, {
+				:message => "module #{mod} in communicator.rb, send_command : command unavaliable or bad module code",
+				:level => Logger::WARN
+			})
+			begin
+				block.call() unless block.nil?	# Block will inform of any errors
+			rescue => x
+				AutomateEm.print_error(logger, x, {
+					:message => "in communicator.rb, send_command : interface provided bad block",
+					:level => Logger::ERROR
+				})
+			end
+		ensure
+			ActiveRecord::Base.clear_active_connections!
+		end
+	end
+	
+	
+	def attach(interface)
+		@status_lock.synchronize {
+			return nil if @shutdown || interface.nil?
+			@connected_interfaces[interface] = [] unless @connected_interfaces.include?(interface)
+		}
+		return self
+	end
+	
+	
+	protected
+	
+	
+	def unregister_all(interface)
+		# TODO:: Important to stop memory leaks
+	end
+end
+end