automate-em 0.0.1

data/lib/automate-em/interfaces/OLD CODE/telnet/telnet.rb

@@ -0,0 +1,137 @@
+#require 'rubygems'
+#require 'eventmachine'
+
+
+require "#{File.dirname(__FILE__)}/ansi.rb"
+require 'json'
+
+module Control
+	class TelnetServer < Deferred
+	
+		def initialize(*args)
+			super
+			
+			@input_lock = Mutex.new
+		end
+
+		def self.start
+			EventMachine::start_server "127.0.0.1", 23, TelnetServer
+			System.logger.info 'running telnet server on 23'
+		end
+ 
+		def received
+			@input_lock.synchronize {
+				data = @receive_queue.pop(true)		
+				if data == "\b"
+					if @input.length > 0
+						send_data " \b"
+						@input.chop!
+					else
+						send_data " "
+					end
+				elsif data =~ /.*\r\n$/
+		
+					#
+					# TODO:: For linux we need to chop! twice here
+					#	Windows @input is already complete
+					#
+
+					if @input =~ /^(quit|exit)$/i 
+						disconnect
+						return
+					end
+
+					if @input != "" && !@input.nil?
+						if @selected.nil?
+							if @input =~ /^\d+$/
+								@selected = Communicator.select(self, @input.to_i)
+							else
+								@selected = Communicator.select(self, @input)
+							end
+							send_line " system #{@input} selected...", :green
+						else
+							thecommand = @input.split(/\s|\./, 3)
+							@input = ""
+							on_fail = lambda {
+								send_line(" invalid command", :green)
+								send_prompt("> ", :green)
+								send_prompt(@input)
+							}
+							if thecommand[0] =~ /register/i
+								@selected.register(self, thecommand[1], thecommand[2], &on_fail)
+							elsif thecommand[0] =~ /unregister/i
+								@selected.unregister(self, thecommand[1], thecommand[2], &on_fail)
+							elsif thecommand[2].nil?
+								@selected.send_command(thecommand[0], thecommand[1], &on_fail)
+							elsif ['{','['].include?(thecommand[2][0])
+								@selected.send_command(thecommand[0], thecommand[1], JSON.parse(thecommand[2], {:symbolize_names => true}), &on_fail)
+							else
+								@selected.send_command(thecommand[0], thecommand[1], thecommand[2], &on_fail)
+							end
+							send_line " sent...", :green
+						end
+					end
+
+					send_prompt("> ", :green)
+					@input = ""
+				else #if data =~ /^[a-zA-Z0-9\., _-]*$/
+					@input << data
+				end
+			}
+		end
+		
+		def notify(mod_sym, stat_sym, data)
+			send_line("\r\nStatus: #{mod_sym}:#{stat_sym}==#{data}", :green)
+			send_prompt("> ", :green)
+			@input_lock.synchronize {
+				send(@input) if !@input.empty?
+			}
+		end
+	
+		protected
+	
+		def initiate_session
+			@input_lock.synchronize {
+				@input = ""
+			}
+			send_line("Please select from the following systems:", :green)
+			send_line("-----------------------------------------", :green)
+			system = Communicator.system_list
+			system.each_index { |x| send_line(" #{x}: #{system[x]}", :green) }
+			send_prompt("> ", :green)
+		end
+	
+		def disconnect
+			send_line("Goodbye.", :green)
+			close_connection_after_writing
+		end
+	
+		def send_line(data, color=nil)
+			send(data, color, true)
+		end
+
+		def send_prompt(data, color=nil)
+			send(data, color, false)
+		end
+	
+		def send(data, color=nil, newline=false)
+			if newline
+				data = data + "\r\n" 
+			end
+ 
+			case color
+			when :red
+				send_data(ANSI.red(data))
+			when :green
+				send_data(ANSI.green(data))
+			else
+				send_data(data)
+			end
+		end
+	end
+end
+
+#EventMachine::run {
+#	EventMachine::start_server "127.0.0.1", 8080, TelnetServer
+#	puts 'running echo server on 8080'
+#}

data/lib/automate-em/interfaces/html5.rb

@@ -0,0 +1,302 @@
+require 'em-websocket'
+require 'json'
+
+
+#
+# This system was designed based on the following articles
+#			https://gist.github.com/299789
+#			http://blog.new-bamboo.co.uk/2010/2/10/json-event-based-convention-websockets
+#
+
+
+class HTML5Monitor
+	@@clients = {}
+	@@special_events = {
+		"system" => :system,
+		"authenticate" => :authenticate,
+		"ls" => :ls,
+		"ping" => :ping
+	}
+	@@special_commands = {
+		"register" => :register,
+		"unregister" => :unregister
+	}
+
+	def self.register(id)
+		@@clients[id] = HTML5Monitor.new(id)
+	end
+	
+	def self.unregister(id)
+		client = @@clients.delete(id)
+		
+		EM.defer do
+			begin
+				client.disconnected
+				AutomateEm::System.logger.debug "There are now #{HTML5Monitor.count} HTML5 clients connected"
+			rescue => e
+				AutomateEm.print_error(AutomateEm::System.logger, e, {
+					:message => "in html5.rb, onclose : unregistering client did not exist (we may have been shutting down)",
+					:level => Logger::ERROR
+				})
+			end
+		end
+	end
+	
+	def self.count
+		return @@clients.length
+	end
+	
+	def self.receive(id, data)
+		client = @@clients[id]
+		
+		EM.defer do
+			begin
+				client.receive(data)
+			rescue => e
+				AutomateEm.print_error(AutomateEm::System.logger, e, {
+					:message => "in html5.rb, onmessage : client did not exist (we may have been shutting down)",
+					:level => Logger::ERROR
+				})
+			ensure
+				ActiveRecord::Base.clear_active_connections!	# Clear any unused connections
+			end
+		end
+	end
+	
+	
+	def initialize(socket)
+		@data_lock = Mutex.new
+		
+		#
+		# Must authenticate before any system details will be sent
+		#
+		@socket = socket
+		@system = nil
+		@user = nil
+		
+		
+		@socket.send(JSON.generate({:event => "authenticate", :data => []}))
+		
+		#
+		# TODO:: start a schedule here that sends a ping to the browser every so often
+		#
+	end
+	
+	
+	#
+	#
+	# Instance methods:
+	#
+	#
+	def try_auth(data = nil)
+		
+		return false if @ignoreAuth
+
+		if !!@user
+			if data.nil?
+				return true
+			else
+				@user = nil
+				return try_auth(data)
+			end
+		else
+			if !data.nil? && data.class == Array
+				if data.length == 1	# one time key
+					@user = TrustedDevice.try_to_login(data[0])
+				elsif data.length == 3
+											#user, password, auth_source
+					source = AuthSource.where("name = ?", data[2]).first
+					@user = User.try_to_login(data[0], data[1], source)
+				end
+				
+				return try_auth	# no data
+			end
+			
+			#
+			# Prevent DOS/brute force Attacks
+			#
+			@ignoreAuth = true
+			EM.add_timer(2) do
+				begin
+					@socket.send(JSON.generate({:event => "authenticate", :data => []}))
+				ensure
+					@ignoreAuth = false
+				end
+			end
+		end
+		return false
+	end
+	
+	def send_system
+		return if @ignoreSys	
+		@ignoreSys = true
+		
+		EM.add_timer(2) do
+			begin
+				@socket.send(JSON.generate({:event => "system", :data => []}))
+			ensure
+				@ignoreSys = false
+			end
+		end
+	end
+	
+	def disconnected
+		@data_lock.synchronize {
+			@system.disconnected(self) if (!!@system)	# System could be nil or false
+		}
+	end
+	
+	def receive(data)
+		data = JSON.parse(data, {:symbolize_names => true})
+		return unless data[:command].class == String
+		data[:data] = [] unless data[:data].class == Array
+
+		@data_lock.synchronize {
+			#
+			# Ensure authenticated
+			#
+			if data[:command] == "authenticate"
+				return unless try_auth(data[:data])
+				send_system
+				return
+			else
+				return unless (try_auth || data[:command] == "ping")
+			end
+			
+			#
+			# Ensure system is selected
+			#	If a command is sent out of order
+			#
+			if @system.nil? && !@@special_events.has_key?(data[:command])
+				send_system
+				return
+			end
+			
+			if @@special_events.has_key?(data[:command])		# system, auth, ls
+				case @@special_events[data[:command]]
+					when :system
+						@system.disconnected(self) unless @system.nil?
+						@system = nil
+						@system = AutomateEm::Communicator.select(@user, self, data[:data][0]) unless data[:data].empty?
+						if @system.nil?
+							send_system
+						elsif @system == false	# System offline
+							EM.schedule do
+								@socket.send(JSON.generate({:event => "offline", :data => []}))
+								shutdown
+							end
+						else
+							EM.schedule do
+								@socket.send(JSON.generate({:event => "ready", :data => []}))
+							end
+						end
+					when :ping
+						EM.schedule do
+							@socket.send(JSON.generate({:event => "pong", :data => []}))
+						end
+					when :ls
+						systems = AutomateEm::Communicator.system_list(@user)
+						EM.schedule do
+							@socket.send(JSON.generate({:event => "ls", :data => systems}))
+						end
+				end
+			elsif @@special_commands.has_key?(data[:command])	# reg, unreg
+				array = data[:data]
+				array.insert(0, self)
+				@system.public_send(data[:command], *array)
+			else									# All other commands
+				command = data[:command].split('.')
+				if command.length == 2
+					@system.send_command(command[0], command[1], *data[:data])
+				else
+					AutomateEm::System.logger.info "-- in html5.rb, recieve : invalid command received - #{data[:command]} --"
+				end
+			end
+		}
+	rescue => e
+		logger = nil
+		@data_lock.synchronize {
+			logger = @system.nil? ? AutomateEm::System.logger : @system.logger
+		}
+		AutomateEm.print_error(logger, e, {
+			:message => "in html5.rb, recieve : probably malformed JSON data",
+			:level => Logger::ERROR
+		})
+		shutdown
+	end
+	
+	def shutdown
+		EM.schedule do
+			@socket.close_websocket
+		end
+	end
+	
+	def notify(mod_sym, stat_sym, data)
+		#
+		# This should be re-entrant? So no need to protect
+		#
+		@system.logger.debug "#{mod_sym}.#{stat_sym} sent #{data.inspect}"
+		EM.schedule do
+			@socket.send(JSON.generate({"event" => "#{mod_sym}.#{stat_sym}", "data" => data}))
+		end
+	end
+end
+
+
+module AutomateEm
+	class System
+		@@socket_server = nil
+		def self.start_websockets
+			EM.schedule do
+				if @@socket_server.nil?
+					@@socket_server = EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 81) do |socket| # , :debug => true
+						socket.onopen {
+							#
+							# This socket represents a connected device
+							#
+							HTML5Monitor.register(socket)
+						}
+						
+						socket.onmessage { |data|
+							#
+							# Attach socket here to system
+							#	then process commands
+							#
+							HTML5Monitor.receive(socket, data)
+						}
+				
+						socket.onclose {
+							HTML5Monitor.unregister(socket)
+						}
+						
+						socket.onerror { |error|
+							if !error.kind_of?(EM::WebSocket::WebSocketError)
+								EM.defer do
+									AutomateEm.print_error(AutomateEm::System.logger, error, {
+										:message => "in html5.rb, onerror : issue with websocket data",
+										:level => Logger::ERROR
+									})
+								end
+							else
+								EM.defer do
+									AutomateEm::System.logger.info "in html5.rb, onerror : invalid handshake received - #{error.inspect}"
+								end
+							end
+						}
+					end
+				
+				end
+			end
+			EM.defer do
+				AutomateEm::System.logger.info 'running HTML5 socket server on port 81'
+			end
+		end
+		
+		def self.stop_websockets
+			EM.schedule do
+				EventMachine::stop_server(@@socket_server) unless @@socket_server.nil?
+				@@socket_server = nil
+			end
+		end
+	end
+end

data/lib/automate-em/logic/logic.rb

@@ -0,0 +1,76 @@
+module AutomateEm
+
+	#
+	# Base class for all control logic classes
+	#
+	class Logic
+		include Status
+		include Constants
+		include Utilities
+		
+		def initialize(system)
+			@system = system
+			
+			#
+			# Status variables
+			#	NOTE:: if changed then change in device.rb 
+			#
+			@status = {}
+			@status_lock = Mutex.new
+			@status_emit = {}	# status => condition_variable
+		end
+		
+
+		def logger
+			@system.logger
+		end
+		
+		
+		def clear_active_timers
+			@schedule.clear_jobs unless @schedule.nil?
+		end
+
+		
+		protected
+		
+
+		def setting(name)
+			val = LogicModule.lookup(self).settings.where("name = ?", name).first
+			if val.nil?
+				val = LogicModule.lookup(self).control_system.zones.joins(:settings).where('settings.name = ?', name.to_s).first
+				val = val.settings.where("name = ?", name.to_s).first unless val.nil?
+				
+				val = LogicModule.lookup(self).dependency.settings.where("name = ?", name).first if val.nil?
+			end
+			
+			if val.present?
+				case val.value_type
+					when 0
+						return val.text_value
+					when 1
+						return val.integer_value
+					when 2
+						return val.float_value
+					when 3
+						return val.datetime_value
+				end
+			end
+			
+			return nil
+		end
+		
+
+		attr_reader :system
+		
+		
+		def register(mod, status, &block)
+			@system.communicator.register(self, mod, status, &block) 
+		end
+		
+		def unregister(mod, status, &block)
+			@system.communicator.unregister(self, mod, status, &block) 
+		end
+
+		
+	end
+end