automate-em 0.0.1

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

@@ -0,0 +1,48 @@
+module AutomateEm
+
+	class Service
+		include ModuleCore
+		
+		def initialize
+			@systems = []
+
+			#
+			# Status variables
+			#	NOTE:: if changed then change in logic.rb 
+			#
+			@status = {}
+			@status_lock = Mutex.new
+			@system_lock = Mutex.new
+			@status_waiting = false
+		end
+		
+		protected
+		
+		def config
+			ServiceModule.lookup(self)
+		end
+		
+		def request(path, options = {}, *args, &block)
+			error = true
+			
+			begin
+				error = @base.do_send_request(path, options, *args, &block)
+			rescue => e
+				AutomateEm.print_error(logger, e, {
+					:message => "module #{self.class} in request",
+					:level => Logger::ERROR
+				})
+			ensure
+				if error
+					begin
+						logger.warn "Request failed for: #{path.inspect}"
+					rescue
+						logger.error "Request failed, bad path data"
+					end
+				end
+			end
+			
+		end
+	end
+	
+end

data/lib/automate-em/status.rb

@@ -0,0 +1,89 @@
+module AutomateEm
+
+	module Status
+		include Observable
+
+
+		def [] (status)
+			status = status.to_sym if status.class == String
+			@status_lock.synchronize {
+				return @status[status]
+			}
+		end
+		
+		def []= (status, data)
+			status = status.to_sym if status.class == String
+			old_data = check_for_emit(status, data)
+			
+			if data != old_data
+				changed								# so that the notify is applied
+				logger.debug "#{self.class} status updated: #{status} = #{data}"
+			end
+			
+			
+			notify_observers(self, status, data)	# only notify changes
+		end
+		
+		attr_reader :status	# Should not be accessed like this for modification
+		
+		
+		def mark_emit_start(status)
+			@status_lock.synchronize {
+				@emit_hasnt_occured = status
+			}
+		end
+		
+		def mark_emit_end
+			@status_lock.synchronize {
+				@emit_hasnt_occured.each_pair do | key, block |
+					data = @status[key]
+					task do
+						begin
+							block.call(data)
+						ensure
+							ActiveRecord::Base.clear_active_connections!
+						end
+					end
+					logger.debug "A forced emit on #{status} occured"
+				end
+				
+				@emit_hasnt_occured = nil
+			}
+		end
+		
+		
+		protected
+		
+		
+		def check_for_emit(status, data)
+			@status_lock.synchronize {
+				old_data = @status[status]
+				@status[status] = data
+				
+				if @emit_hasnt_occured.present?
+					begin
+						if @emit_hasnt_occured.has_key?(status)
+							@base.received_lock.mon_exit				# check we are in the recieved queue
+							@base.received_lock.mon_enter
+						
+							block = @emit_hasnt_occured.delete(status)
+							task do
+								begin
+									block.call(data)
+								ensure
+									ActiveRecord::Base.clear_active_connections!
+								end
+							end
+						#logger.debug "Emit clear success: #{status}"
+						end
+					rescue
+						logger.debug "An emit on #{status} occured outside received function"
+					end
+				end
+				
+				return old_data
+			}
+		end
+	end
+
+end

data/lib/automate-em/utilities.rb

@@ -0,0 +1,195 @@
+
+
+module AutomateEm
+	def self.print_error(logger, e, options = {})
+
+		begin
+			level = options[:level] || Logger::INFO
+			logger.add(level) do
+				message = options[:message].nil? ? "" : "%p" % options[:message]
+				message += "\n#{e.message}"
+				e.backtrace.each {|line| message += "\n#{line}"}
+				message
+			end
+		rescue
+		end
+
+	end
+	
+	class JobProxy
+		
+		instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+		
+		def initialize(jobs, index, lock)
+			@jobs = jobs
+			@index = index
+			@job = @jobs[@index]	# only ever called from within the lock
+		end
+		
+		
+		def unschedule
+			EM.schedule do
+				begin
+					@job.unschedule
+					@jobs.delete(@index)
+				rescue
+				end
+			end
+		end
+		
+		protected
+		
+		def method_missing(name, *args, &block)
+			EM.schedule do
+				@job.send(name, *args, &block)
+			end
+		end
+	end
+	
+	class ScheduleProxy
+		
+		instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+		
+		def initialize
+			@jobs = {}
+			@index = 0
+		end
+		
+		def clear_jobs
+			EM.schedule do
+				@jobs.each_value do |job|
+					job.unschedule
+				end
+				
+				@jobs = {}
+				@index = 0
+			end
+		end
+		
+		protected
+		
+		def method_missing(name, *args, &block)
+			EM.schedule do
+				begin
+					if block.present?
+						job = nil
+						
+						if [:in, :at].include?(name)
+							index = @index				# local variable for the block
+							
+							job = AutomateEm::scheduler.send(name, *args) do
+								begin
+									block.call
+								rescue => e
+									AutomateEm.print_error(System.logger, e, :message => "Error in one off scheduled event")
+								ensure
+									EM.schedule do
+										@jobs.delete(index)
+									end
+								end
+							end
+						else
+							job = AutomateEm::scheduler.send(name, *args) do
+								begin
+									block.call
+								rescue => e
+									AutomateEm.print_error(System.logger, e, :message => "Error in repeated scheduled event")
+								end
+							end
+						end
+						
+						if job.present?
+							@jobs[@index] = job
+							job = JobProxy.new(@jobs, @index, @job_lock)
+							
+							@index += 1
+							
+							return job
+						end
+						
+						return nil
+					else
+						AutomateEm::scheduler.send(name, *args, &block)
+					end
+				rescue
+				end
+			end
+        end
+	end
+	
+	module Utilities
+		#
+		# Converts a hex encoded string into a raw byte string
+		#
+		def hex_to_byte(data)	# Assumes string - converts to binary string
+			data.gsub!(/(0x|[^0-9A-Fa-f])*/, "")				# Removes invalid characters
+			output = ""
+			data = "0#{data}" if data.length % 2 > 0
+			data.scan(/.{2}/) { |byte| output << byte.hex}	# Breaks string into an array of characters
+			return output
+		end
+		
+		#
+		# Converts a raw byte string into a hex encoded string
+		#
+		def byte_to_hex(data)	# Assumes string - converts from a binary string
+			output = ""
+			data.each_byte { |c|
+				s = c.to_s(16)
+				s = "0#{s}" if s.length % 2 > 0
+				output << s
+			}
+			return output
+		end
+		
+		#
+		# Converts a string into a byte array
+		#
+		def str_to_array(data)
+			data.bytes.to_a
+		end
+		
+		#
+		# Converts an array into a raw byte string
+		#
+		def array_to_str(data)
+			data.pack('c*')
+		end
+		
+		#
+		# Creates a new threaded task
+		#
+		def task(callback = nil, &block)
+			EM.defer(nil, callback) do
+				begin
+					block.call
+				rescue => e
+					AutomateEm.print_error(System.logger, e, :message => "Error in task")
+				end
+			end
+		end
+		
+		
+		#
+		# Schedule events
+		#
+		def schedule
+			return @schedule unless @schedule.nil?
+			@status_lock.synchronize {
+				@schedule ||= ScheduleProxy.new
+			}
+        end
+		
+		
+		#
+		# Makes functions private when included in a class
+		#
+		module_function :hex_to_byte
+		module_function :byte_to_hex
+		module_function :str_to_array
+		module_function :array_to_str
+		
+		module_function :schedule
+		module_function :task
+	end
+end

data/lib/automate-em/version.rb

@@ -0,0 +1,3 @@
+module AutomateEm
+  VERSION = "0.0.1"
+end

data/lib/generators/module/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a module scaffold for you
+
+Example:
+    rails generate module manufacturer/category/module_name
+
+    This will create:
+        app/modules/manufacturer/category/module_name.rb

data/lib/generators/module/module_generator.rb

@@ -0,0 +1,47 @@
+class ModuleGenerator < Rails::Generators::NamedBase
+	#source_root File.expand_path('../templates', __FILE__)
+	
+	def create_module_file
+		
+		name = file_name.downcase.gsub(/\s|-/, '_')
+		param = class_path
+		param.map! {|item| item.downcase.gsub(/\s|-/, '_')}
+		
+		path = File.join('app/modules', *param)
+		
+		scope = []
+		text = ""
+		param.map! {|item|
+			item = item.classify
+			scope << item
+			text += "module #{scope.join('::')}; end\n"
+			item
+		}
+		param << name.classify
+		scope = param.join('::')
+		
+		
+		create_file File.join(path, "#{name}.rb") do
+			type = ask("What type of module (device, service, logic) will this be?")
+			
+			text += <<-FILE
+
+
+class #{scope} < AutomateEm::#{type.downcase.classify}
+	def on_load
+	end
+	
+	def on_unload
+	end
+	
+	def on_update
+	end
+end
+
+			FILE
+			
+			text
+		end
+		
+	end
+end

data/lib/tasks/automate-em_tasks.rake

@@ -0,0 +1,5 @@
+
+desc 'Start the automation server'
+task :automate => :environment do
+	AutomateEm.boot
+end

data/test/automate-em_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class AutomateEmTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, AutomateEm
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.