automate-em 0.0.1

data/lib/automate-em/device/tcp_control.rb

@@ -0,0 +1,210 @@
+require 'atomic'
+
+module AutomateEm
+
+	class Device
+	
+
+		#
+		# This is how sending works
+		#		Send recieves data, turns a mutex on and sends the data
+		#			-- It goes into the recieve mutex critical section and sleeps waiting for a response
+		#			-- a timeout is used as a backup in case no response is received
+		#		The recieve function does the following
+		#			-- If the send lock is not active it processes the received data
+		#			-- otherwise it notifies the send function that data is avaliable
+		#
+		class Base < EventMachine::Connection
+			include Utilities
+			include DeviceConnection
+			
+			#
+			# EM Callbacks: --------------------------------------------------------
+			#
+			#def post_init
+			#	return unless @parent.respond_to?(:initiate_session)
+			#	
+			#	begin
+			#		@parent.initiate_session(@tls_enabled)
+			#	rescue => e
+			#		#
+			#		# save from bad user code (don't want to deplete thread pool)
+			#		#
+			#		EM.defer do
+			#			logger.error "-- module #{@parent.class} error whilst calling: initiate_session --"
+			#			logger.error e.message
+			#			logger.error e.backtrace
+			#		end
+			#	end
+			#end
+
+	
+			def connection_completed
+				# set status
+				resume if paused?
+				
+				@connect_retry = @connect_retry || Atomic.new(0)
+				EM.defer do
+					@connect_retry.value = 0
+				end
+				
+				if !@tls_enabled
+					@connected = true
+					@connecting = false
+					EM.defer do
+						call_connected
+					end
+				else
+					if !@parent.respond_to?(:certificates)
+						start_tls
+					else
+						begin
+							certs = @parent.certificates
+							start_tls(certs)
+						rescue => e
+							EM.defer do
+								AutomateEm.print_error(logger, e, {
+									:message => "module #{@parent.class} error whilst starting TLS with certificates",
+									:level => Logger::ERROR
+								})
+							end
+						end
+					end
+				end
+
+				@make_occured = true
+			end
+			
+			def ssl_handshake_completed
+				@connected = true
+				@connecting = false
+				EM.defer do
+					call_connected(get_peer_cert)		# this will mark the true connection complete stage for encrypted devices
+				end
+			end
+			
+
+			def unbind
+				@connected = false	# set offline
+				@connecting = false
+				@disconnecting = false
+
+				if @config[:flush_buffer_on_disconnect]
+					process_response(@buf.flush, nil) unless @buf.nil?
+				else
+					@buf.flush unless @buf.nil?	# Any incomplete from TCP stream is now invalid
+				end
+
+				@connect_retry = @connect_retry || Atomic.new(0)
+				
+				if @config[:clear_queue_on_disconnect] || (@make_break && !@make_occured)
+					@send_queue.clear
+				end
+				@make_occured = false
+				
+				EM.defer do
+					if !@shutting_down.value
+						
+						@task_queue.push lambda {
+							@parent[:connected] = false
+							return unless @parent.respond_to?(:disconnected)
+							begin
+								@parent.disconnected
+							rescue => e
+								#
+								# save from bad user code (don't want to deplete thread pool)
+								#
+								AutomateEm.print_error(logger, e, {
+									:message => "module #{@parent.class} error whilst calling: disconnected",
+									:level => Logger::ERROR
+								})
+							end
+						}
+					end
+				end
+				
+				if !@make_break
+					do_connect
+				elsif @send_queue.size() > 0
+					do_connect
+				end
+			end
+
+			def do_connect
+				if @disconnecting
+					EM.next_tick do
+						do_connect
+					end
+					return
+				end
+				return if @connected	# possible to get here
+
+				makebreak = @make_break
+				@connecting = true
+				EM.defer do
+					if !@shutting_down.value
+						begin
+							settings = DeviceModule.lookup(@parent)	#.reload # Don't reload here (user driven)
+							
+							@connect_retry.update { |v| v += 1}
+							
+							if @connect_retry.value == 1 || makebreak
+								res = ResolverJob.new(settings.ip)
+								res.callback {|ip|
+									reconnect ip, settings.port
+								}
+								res.errback {|error|
+									EM.defer do
+										logger.info "module #{@parent.class} in tcp_control.rb, unbind"
+										logger.info "Reconnect failed for #{settings.ip}:#{settings.port} - #{error.inspect}"
+									end
+									@connect_retry.value = 2
+									do_reconnect(settings) unless makebreak
+								}
+							else
+								#
+								# log this once if had to retry more than once
+								#
+								if @connect_retry.value == 2
+									logger.info "module #{@parent.class} in tcp_control.rb, unbind"
+									logger.info "Reconnect failed for #{settings.ip}:#{settings.port}"
+								end
+				
+								do_reconnect(settings)
+							end
+						rescue
+							AutomateEm.print_error(logger, e, {
+								:message => "module #{@parent.class} in tcp_control.rb, unbind\nFailed to lookup settings. Device probably going offline.",
+								:level => Logger::FATAL
+							})
+							
+							# Do not attempt to reconnect this device!
+						end
+					end
+				end
+			end
+			
+			def do_reconnect(settings)
+				EM::Timer.new(5) do
+					if !@shutting_down.value
+						res = ResolverJob.new(settings.ip)
+						res.callback {|ip|
+							reconnect ip, settings.port
+						}
+						res.errback {|error|
+							do_reconnect(settings)
+						}
+					end
+				end
+			end
+			
+			def receive_data(data)
+				do_receive_data(data)
+			end
+			
+			def do_send_data(data)
+				send_data(data)
+			end
+		end
+	end
+end

data/lib/automate-em/engine.rb

@@ -0,0 +1,36 @@
+module AutomateEm
+	class Engine < ::Rails::Engine
+		engine_name :automate
+		
+		
+		rake_tasks do
+			load "tasks/automate-em_tasks.rake"
+		end
+		
+		#
+		# Define the application configuration
+		#
+		config.before_initialize do |app|						# Rails.configuration
+			app.config.automate = ActiveSupport::OrderedOptions.new
+			app.config.automate.module_paths = []
+			app.config.automate.log_level = Logger::INFO
+		end
+		
+		#
+		# Discover the possible module location paths after initialisation is complete
+		#
+		config.after_initialize do |app|
+			
+			app.config.assets.paths.each do |path|
+				Pathname.new(path).ascend do |v|
+					if ['app', 'vendor'].include?(v.basename.to_s)
+						app.config.automate.module_paths << "#{v.to_s}/modules"
+						break
+					end
+				end
+			end
+			
+			app.config.automate.module_paths.uniq!
+		end
+	end
+end

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

@@ -0,0 +1,67 @@
+
+
+#
+# This reduces load on the reactor thread.
+#	Use as a helper if desired
+#
+module Control
+	class Deferred < EventMachine::Connection
+		def initialize(*args)
+			super
+
+			@selected = nil
+			@receive_queue = Queue.new
+			@command_lock = Mutex.new
+		end
+		
+		def post_init
+			return unless self.respond_to?(:initiate_session)
+			begin
+				self.initiate_session
+			rescue => e
+				if !@system.nil?
+					@system.logger.error "-- in defferred.rb, post_init : bad user code in #{self.class}.initiate_session --"
+					@system.logger.error e.message
+					@system.logger.error e.backtrace
+				end
+			end
+		end
+		
+		def connection_completed
+			if self.respond_to?(:connected)
+				EM.defer do
+					begin
+						self.connected
+					rescue => e
+						if !@system.nil?
+							@system.logger.error "-- in defferred.rb, connection_completed : bad user code in #{self.class}.connected --"
+							@system.logger.error e.message
+							@system.logger.error e.backtrace
+						end
+					end
+				end
+			end
+		end
+		
+		def unbind
+			@selected.disconnected(self) unless @selected.nil?
+		end
+		
+		def receive_data(data)
+			@receive_queue.push(data)
+			EM.defer do
+				begin
+					@command_lock.synchronize {
+						self.received
+					}
+				rescue => e
+					if !@system.nil?
+						@system.logger.error "-- in defferred.rb, receive_data : bad user code in #{self.class}.received --"
+						@system.logger.error e.message
+						@system.logger.error e.backtrace
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,137 @@
+#taken from the dorkbuster gem
+
+module ANSI
+	Reset	 = "0"
+	Bright	= "1"
+	
+	Black	 = "30"
+	Red		 = "31"
+	Green	 = "32"
+	Yellow	= "33"
+	Blue		= "34"
+	Magenta = "35"
+	Cyan		= "36"
+	White	 = "37"
+	
+	BGBlack	 = "40"
+	BGRed		 = "41"
+	BGGreen	 = "42"
+	BGYellow	= "43"
+	BGBlue		= "44"
+	BGMagenta = "45"
+	BGCyan		= "46"
+	BGWhite	 = "47"
+	
+	Bright_Magenta	= Bright+';'+BGBlack+';'+Magenta	#	 "1;35;40"
+
+	class << self
+		def color(*colors)
+			"\033[#{colors.join(';')}m"
+		end
+		
+		def colorize(str, start_color, end_color = Reset)
+			"#{color(start_color)}#{str}#{color(end_color)}"
+		end
+
+		def attr_is_fgcolor?(str)
+			str.to_i.between?(30, 37)
+		end
+		
+		def attr_is_bgcolor?(str)
+			str.to_i.between?(40, 47)
+		end
+		
+		def strip(str)
+			str.gsub(/\e\[[\d;]*[A-Za-z]/, "")
+		end
+
+		def strlen(str)
+			str.strip.length
+		end
+		
+		def strclip(str, len)
+			out = ""
+			nout = 0
+			str.scan(/\e\[[\d;]*[A-Za-z]|[^\e]/) do |tok|
+				if tok[0] != ?\e
+					nout += 1
+					break if nout > len
+				end
+				out << tok
+			end
+			out
+		end
+
+		def strbreak(str, len)
+			out = []
+			buf = ""
+			nout = 0
+			str.scan(/\e\[[\d;]*[A-Za-z]|[^\e]/) do |tok|
+				if tok[0] != ?\e
+					nout += 1
+					if nout > len
+			out << buf
+			nout -= len
+			buf = ""
+		end
+				end
+				buf << tok
+			end
+			out << buf unless buf.empty?
+			out
+		end
+		
+		def red(str);		 colorize(str, Red) end
+		def green(str);	 colorize(str, Green) end
+		def yellow(str);	colorize(str, Yellow) end
+		def blue(str);		colorize(str, Blue) end
+		def magenta(str); colorize(str, Magenta) end
+		def cyan(str);		colorize(str, Cyan) end
+	
+		def bright_magenta(str); colorize(str, Bright_Magenta) end
+	
+		def set_scroll_fullscreen; "\e[r" end
+		def set_scroll_region(row_start, row_end); "\e[#{row_start};#{row_end}r" end
+		
+		def set_cursor_pos(row, col); "\e[#{row};#{col}H" end
+		
+		def cursor_left(cnt=1);	"\e[#{cnt}D" end
+		def cursor_right(cnt=1); "\e[#{cnt}C" end
+		def cursor_up(cnt=1);		"\e[#{cnt}A" end
+		def cursor_down(cnt=1);	"\e[#{cnt}B" end
+		
+		def save_cursor_pos;		"\e[s" end
+		def restore_cursor_pos; "\e[u" end
+
+		def backspace_rubout(cnt=1); ("\b \b" * cnt) end
+		
+		def erase_line; "\e[2K" end
+		def erase_eol; "\e[K" end
+
+	end
+end
+
+
+
+if $0 == __FILE__
+	require 'test/unit'
+
+	class TestANSI < Test::Unit::TestCase
+
+		def test_strclip
+			assert_equal( "ab\e[34;56mc", ANSI.strclip("ab\e[34;56mcd", 3) )
+			assert_equal( "ab\e[34;56mc\e[12;34r\e[H", ANSI.strclip("ab\e[34;56mc\e[12;34r\e[Hd", 3) )
+			assert_equal( "ab\e[34;56mc\e[12;34r\e[Hd", ANSI.strclip("ab\e[34;56mc\e[12;34r\e[Hde", 4) )
+			assert_equal( "ab\e[34;56mc\e[12;34r\e[Hde", ANSI.strclip("ab\e[34;56mc\e[12;34r\e[Hde", 5) )
+		end
+
+		def test_strbreak
+			assert_equal( ["ab\e[34;56mc", "d"], ANSI.strbreak("ab\e[34;56mcd", 3) )
+			assert_equal( ["ab\e[34;56m", "c\e[12;34r\e[Hd", "e"], ANSI.strbreak("ab\e[34;56mc\e[12;34r\e[Hde", 2) )
+		end
+		
+	end
+
+end
+
+