coral_plan 0.1.1

data/README.rdoc

@@ -0,0 +1,48 @@
+= coral_plan
+
+This library provides the ability to create, load, execute, and save 
+execution plans.
+
+The Coral Plan library contains a system that defines execution plans of 
+CLI commands.  The goal is to make it easy to create, edit, load, execute,
+and save these plans in a machine readable format (ie; JSON).  The system 
+is composed of Events, Commands, Actions, and of course Plans. There are a
+few simple rules:
+    
+1. All plans begin with a Command but may have more Commands defined
+   that act in sequence unless there are errors with previous commands.
+    
+2. Commands can trigger Events of various types, where Events are reading
+   and checking (ie; Regular expressions) Command output line by line.
+       
+3. Events have different criteria for measuring success and will have 
+   different fields.  For example, a Regexp event contains a 'pattern'
+   field.
+       
+4. Actions listen for Events and run Commands, with the ability to override
+   default Command parameters.  Actions may also generate Events on either
+   successful execution or failure which can trigger other Actions.
+       
+Note:  This library is still very early in development!
+
+== Contributing to coral_plan
+ 
+* Check out the latest master to make sure the feature hasn't been implemented 
+  or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested 
+  it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a 
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want 
+  to have your own version, or is otherwise necessary, that is fine, but 
+  please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Licensed under GPLv3.  See LICENSE.txt for further details.
+
+Copyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>
+Coral Technology Group LLC

data/Rakefile

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'jeweler'
+
+require './lib/coral_plan.rb'
+
+#-------------------------------------------------------------------------------
+# Dependencies
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+#-------------------------------------------------------------------------------
+# Gem specification
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name                  = "coral_plan"
+  gem.homepage              = "http://github.com/coraltech/ruby-coral_plan"
+  gem.rubyforge_project     = 'coral_plan'
+  gem.license               = "GPLv3"
+  gem.email                 = "adrian.webb@coraltech.net"
+  gem.authors               = ["Adrian Webb"]
+  gem.summary               = %Q{Provides the ability to create, load, execute, and save execution plans}
+  gem.description           = File.read('README.rdoc')
+  gem.required_ruby_version = '>= 1.8.1'
+  gem.has_rdoc              = true
+  gem.rdoc_options << '--title' << 'Coral Execution Plan library' <<
+                      '--main' << 'README.rdoc' <<
+                      '--line-numbers' 
+  
+  # Dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+#-------------------------------------------------------------------------------
+# Testing
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+#-------------------------------------------------------------------------------
+# Documentation
+
+Rake::RDocTask.new do |rdoc|
+  version = Coral::Plan::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "coral_plan #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/coral_plan/action.rb

@@ -0,0 +1,167 @@
+
+module Coral
+module Plan
+class Action < Core
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    super(options)
+    @plan = ( options.has_key?(:plan) ? options[:plan] : nil )
+    @name = ( options.has_key?(:name) ? string(options[:name]) : '' )      
+  end  
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_accessor :name
+
+  #---
+  
+  def events
+    events = {}
+    @plan.action(@name, 'events', [], :array).each do |name|
+      events[name] = @plan.events[name]
+    end
+    return events
+  end
+  
+  #---
+  
+  def events=events
+    @plan.set_action(@name, "events", events)  
+  end
+  
+  #---
+  
+  def commands
+    commands = []
+    @plan.action(@name, 'commands', [], :array).each do |name|
+      commands << @plan.commands[name]
+    end
+    return commands
+  end
+  
+  #---
+  
+  def commands=commands
+    @plan.set_action(@name, "commands", commands)  
+  end
+  
+  #---
+      
+  def args
+    return search('args', :array)
+  end
+  
+  #---
+  
+  def args=args
+    @plan.set_action(@name, "args", args)  
+  end
+  
+  #---
+    
+  def flags
+    return search('flags', :array)
+  end
+  
+  #---
+  
+  def flags=flags
+    @plan.set_action(@name, "flags", flags)  
+  end
+  
+  #---
+    
+  def data
+    return search('data', :hash)
+  end
+   
+  #---
+  
+  def data=data
+    @plan.set_action(@name, "data", data)  
+  end
+  
+  #---
+    
+  def next
+    commands = []
+    @plan.action(@name, 'next', [], :array).each do |name|
+      commands << @plan.commands[name]
+    end
+    return commands
+  end
+   
+  #---
+  
+  def next=commands
+    @plan.set_action(@name, "next", commands)  
+  end
+  
+  #---
+    
+  def trigger_success
+    return @plan.action('trigger_success', :array)
+  end
+   
+  #---
+  
+  def trigger_success=event_names
+    @plan.set_action(@name, "trigger_success", array(event_names))  
+  end
+  
+  #---
+    
+  def trigger_failure
+    return @plan.action('trigger_failure', :array)
+  end
+   
+  #---
+  
+  def trigger_failure=event_names
+    @plan.set_action(@name, "trigger_failure", array(event_names))  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return symbol_map(@plan.action(@name))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+    
+  def search(key, format = :array)
+    action_info  = @plan.action(@name)
+    action_value = map(action_info[key])
+    
+    merged_value = {}
+    
+    commands.each do |command|
+      command_info  = command.export
+      command_value = ( command_info[key] ? { command.name => filter(command_info[key], format) } : {} )
+           
+      merged_value[name] = Coral::Util::Data.merge([ action_value, command_value ], true)
+    end        
+    return merged_value  
+  end
+  
+  #---
+   
+  def map(data)
+    if data && ! data.is_a?(Hash)
+      data_map = {}
+      commands.each do |command|
+        data_map[command.name] = array(data)
+      end
+      data = data_map
+    end
+    return data  
+  end  
+end
+end
+end

data/lib/coral_plan/base.rb

@@ -0,0 +1,263 @@
+
+module Coral
+module Plan
+
+#*******************************************************************************
+# Errors
+
+class ExecuteError < StandardError 
+end
+
+#*******************************************************************************
+# Base Plan definition
+
+class Base < Memory
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@instances = {}
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.create(name, options = {})
+    options[:name] = name unless options.has_key?(:name)
+    @@instances[name] = new(options) 
+    return @@instances[name]  
+  end
+  
+  #---
+  
+  def self.delete(name) 
+    if @@instances.has_key?(name) && @@instances[name]
+      @@instances.delete(name) 
+    end  
+  end
+  
+  #-----------------------------------------------------------------------------
+ 
+  def self.[](name)
+    if ! @@instances.has_key?(name) || ! @@instances[name]
+      @@instances[name] = new({ :name => name })
+    end 
+    return @@instances[name]  
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def initialize(options = {})
+    super(options)
+    
+    @home = ( options.has_key?(:home) && options[:home].is_a?(Coral::Repository) ? options[:home] : self )  
+        
+    @start_commands = []
+    @commands       = {}
+    @events         = {}
+    @actions        = {}
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_reader :home
+
+  #---
+  
+  def home=home
+    if home && home.is_a?(Coral::Repository)
+      @home = home
+      set_repository(@home.directory, @submodule)
+    end
+  end
+  
+  #---
+  
+  def submodule=submodule
+    set_repository(@home.directory, submodule)
+  end
+   
+  #-----------------------------------------------------------------------------
+  
+  def start(reset = false)
+    if reset || @start_commands.empty?
+      @start_commands = []
+      get('start', [], :array).each do |name|
+        @start_commands << commands[name]
+      end
+    end
+    return @start_commands
+  end
+  
+  #-----------------------------------------------------------------------------
+    
+  def commands(reset = false)
+    if reset || @commands.empty?
+      @commands = {}
+      get('commands', {}, :hash).each do |name, command_info|
+        command_info = Coral::Util::Data.merge([ {
+          :plan   => self,
+          :name   => name,
+        }, symbol_map(command_info) ])
+        
+        @commands[name] = Coral::Plan::Command.new(command_info)
+      end
+    end
+    return @commands
+  end
+    
+  #---
+    
+  def set_commands(commands = {})
+    return set('commands', events)
+  end
+ 
+  #---
+    
+  def command(name, key = nil, default = {}, format = false)
+    return get_group('commands', name, key, default, format)
+  end
+    
+  #---
+
+  def set_command(name, key = nil, value = {})
+    return set_group('commands', name, key, value)
+  end
+    
+  #---
+
+  def delete_command(name, key = nil)
+    return delete_group('commands', name, key)
+  end
+    
+  #-----------------------------------------------------------------------------
+    
+  def events(reset = false)
+    if reset || @events.empty?
+      @events = {}
+      get('events', {}, :hash).each do |name, event_info|
+        event_info = Coral::Util::Data.merge([ {
+          :plan   => self,
+          :name   => name,
+        }, symbol_map(event_info) ])
+      
+        @events[name] = Coral::Plan::Event.instance(event_info)
+      end
+    end
+    return @events
+  end
+    
+  #---
+    
+  def set_events(events = {})
+    return set('events', events)
+  end
+ 
+  #---
+    
+  def event(name, key = nil, default = {}, format = false)
+    return get_group('events', name, key, default, format)
+  end
+    
+  #---
+
+  def set_event(name, key = nil, value = {})
+    return set_group('events', name, key, value)
+  end
+    
+  #---
+
+  def delete_event(name, key = nil)
+    return delete_group('events', name, key)
+  end
+  
+  #-----------------------------------------------------------------------------
+    
+  def actions(reset = false)
+    if reset || @actions.empty?
+      @actions = {}
+      get('actions', {}, :hash).each do |name, action_info|
+        action_info = Coral::Util::Data.merge([ {
+          :plan   => self,
+          :name   => name,
+        }, symbol_map(action_info) ])
+        
+        @actions[name] = Coral::Plan::Action.new(action_info)
+      end
+    end
+    return @actions
+  end
+    
+  #---
+    
+  def set_actions(actions = {})
+    return set('actions', actions)
+  end
+ 
+  #---
+    
+  def action(name, key = nil, default = {}, format = false)
+    return get_group('actions', name, key, default, format)
+  end
+    
+  #---
+
+  def set_action(name, key = nil, value = {})
+    return set_group('actions', name, key, value)
+  end
+    
+  #---
+
+  def delete_action(name, key = nil)
+    return delete_group('actions', name, key)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Execution
+  
+  def run(options)
+    success = true
+    start.each do |command|
+      success = recursive_exec(command, options)
+      break unless success
+    end
+    return success
+  end
+  
+  #---
+  
+  def recursive_exec(command, options = {}, parent_action = nil)
+    success = false
+    
+    options[:info_prefix]  = 'info' unless options.has_key?(:info_prefix)
+    options[:error_prefix] = 'error' unless options.has_key?(:error_prefix)
+    
+    begin
+      triggered_events = command.exec(options, parent_action)
+    rescue
+      raise Coral::Plan::ExecuteError.new(command.name)
+    end
+    
+    if triggered_events
+      success = true
+      
+      unless triggered_events.empty?
+        triggered_events.each do |event_name, event|
+          actions.each do |action_name, action|
+            if action.events.has_key?(event_name)
+              action.commands.each do |subcommand|
+                success = recursive_exec(subcommand, options, action)
+                break unless success
+              end
+            end        
+            break unless success
+          end
+          break unless success
+        end
+      end     
+    end
+    return success
+  end
+end
+end
+end