cook 2.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Not required when using Hoe ruby gem
+Manifest.txt

data/History.txt

@@ -0,0 +1,19 @@
+=== 2.0.1 / 2014-01-15 (external GitHub)
+
+* 2.0.1 minor testing
+
+  * first working release (tested on internal cookbooks)
+
+=== 2.0.0 / 2014-01-15 (external GitHub)
+
+* 2 major enhancement
+
+  * initial preparation for release as a ruby gem 
+
+=== 1.0.0 / 2012-02-01 (internal)
+
+* 1 major enhancement
+
+  * Birthday!
+
+

data/README.txt

@@ -0,0 +1,89 @@
+= cook
+
+home :: https://github.com/stephengaito/rGems-cook
+
+== DESCRIPTION:
+
+cook is a rake extension with:
+
+1. configuration file,
+1. the ability to retrieve passwords from encrypted configuration files,
+1. the ability to create files using Erubis templates,
+1. the ablity to interact with both local and remote shells.
+
+Its main file is a traditional rake Rakefile, which has recipe 
+commands.  Each recipe is a collection of rake task files and 
+associated YAML configuration files, allowing tasks to make use of 
+extensive configuration information.  The configuration is built up 
+from the various fragments in the conf files assocaited with each set 
+of rake tasks.
+
+== FEATURES:
+
+* Based on standard ruby rake 
+
+* Adds the ability to build up configuration from a number of separate
+  configuration files overlaying the more specific configuration
+  parameters over the more general parameters.
+
+* Allows collections of related rake tasks and configuration files in 
+  the form of recipe directories.
+
+* Uses Erubis to create files from templates.
+
+* Uses Greenletters to enable interaction with both local and remote 
+  shells.
+
+* Uses GPGme to obtain passwords from GPG encrypted configuration 
+  files.
+
+== SYNOPSIS:
+
+  cook --config dev update
+
+or
+
+  cook -c prod update
+
+to cook the update task with the additional dev or prod
+configurations.
+
+== REQUIREMENTS:
+
+* rake 
+* construct
+* erubis 
+* greenletters
+* gpgme
+* highline (for requesting GPGme passphrase from command line)
+
+== INSTALL:
+
+To install the cook ruby gem
+
+  $ gem install cook
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 Stephen Gaito
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the 
+'Software'), to deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, merge, publish, 
+distribute, sublicense, and/or sell copies of the Software, and to 
+permit persons to whom the Software is furnished to do so, subject to 
+the following conditions:
+
+The above copyright notice and this permission notice shall be included 
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,45 @@
+# -*- ruby -*-
+
+# To release this ruby gem type:
+#  rake release VERSION=x.y.z
+# where x.y.z is the appropriate version number of this gem.
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :minitest
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+# generate the Manifest.txt file (before we invoke Hoe.spec)
+manifest = FileList[
+  '.gitignore', 
+  'History.*', 
+  'README.*', 
+  'Rakefile',
+  'bin/**/*',
+  'lib/**/*.rb',
+  'test/**/*.rb',
+];
+File.open('Manifest.txt', 'w') do | manifestFile |
+  manifestFile.puts("Manifest.txt");
+  manifestFile.write(manifest.to_a.join("\n"));
+end
+
+# For dependency documentation see:
+#   http://guides.rubygems.org/patterns/
+
+Hoe.spec 'cook' do
+  developer('Stephen Gaito', 'stephen@perceptisys.co.uk')
+  dependency('rake', '~> 0.9.2');
+  dependency('construct', '~> 0.1.7');
+  dependency('erubis', '~> 2.7');
+  dependency('greenletters', '~> 0.2');
+  dependency('gpgme', '~> 2.0');
+  dependency('highline', '~> 1.6.1');
+end
+
+# vim: syntax=ruby

data/bin/cook

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+#--
+#
+# Copyright (c) 2014 Stephen Gaito
+#
+# Permission is hereby granted, free of charge, to any person obtaining 
+# a copy of this software and associated documentation files (the 
+# "Software"), to deal in the Software without restriction, including 
+# without limitation the rights to use, copy, modify, merge, publish, 
+# distribute, sublicense, and/or sell copies of the Software, and to 
+# permit persons to whom the Software is furnished to do so, subject to 
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be 
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+# SOFTWARE. 
+#
+# ++
+
+begin
+  require 'rubygems';
+  gem 'rake';
+rescue LoadError
+end
+
+require 'rake'
+require 'rake/extensions.rb'; # provides mesg used by others
+require 'rake/config.rb';
+require 'rake/cookUtils.rb';
+
+# simulate the --trace option
+Rake.application.options.trace = true;
+Rake.verbose(true);
+
+Rake.application.run

data/bin/cookDecrypt

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+#--
+#
+# Copyright (c) 2014 Stephen Gaito
+#
+# Permission is hereby granted, free of charge, to any person obtaining 
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be 
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE. 
+#
+# ++
+
+
+# based on ideas taken from: 
+# Encrypting and decrypting some data
+# at: http://www.ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html
+# see also:
+# http://www.ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/PKCS5.html
+
+require 'rake'
+require 'rake/extensions.rb'; # provides mesg used by others
+require 'rake/config.rb';
+require 'rake/cookUtils';
+
+if ARGV.length < 1 then
+  puts "usage: cookDecrypt <<cypher text file to decrypt>>.enc";
+  exit(-1);
+end
+
+# check to ensure the file name conforms to our naming conventions...
+#
+if ARGV[0] !~ /\.dec$/ then
+  puts "The file to be decrypted (#{ARGV[0]}) MUST have the file extension '.enc'";
+  exit(-1);
+end
+
+# check to make sure the file exists...
+#
+if !File.exists?(ARGV[0]) then
+  puts "The file to be decrypted (#{ARGV[0]}) does not exist";
+  exit(-1);
+end
+
+# Ensure the configuration has been loaded...
+Rake.application.raw_load_rakefile;
+
+decrypted = "";
+begin
+  decrypted = gpgDecryptFile2Data(ARGV[0]);
+rescue CookDecryptionError => e
+  puts "Failed decryption using GnuPG";
+  puts "(#{e.message})...";
+  puts "\ntrying OpenSSL...";
+  decrypted = openSslDecryptFile2Data(ARGV[0]);
+end
+
+File.open(ARGV[0].sub(/\.enc/,'.dec'),'w') do | decryptedFile |
+  decryptedFile.puts decrypted;
+end

data/bin/cookEncrypt

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+#--
+#
+# Copyright (c) 2014 Stephen Gaito
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# ++
+
+# based on ideas taken from: 
+# Encrypting and decrypting some data
+# at: http://www.ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html
+# see also:
+# http://www.ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/PKCS5.html
+
+require 'rake'
+require 'rake/extensions.rb'; # provides mesg used by others
+require 'rake/config.rb';
+require 'rake/cookUtils';
+
+if ARGV.length < 1 then
+  puts "usage: cookEncrypt <<plain text file to encrypt>>.dec";
+  exit(-1);
+end
+
+# check to ensure the file name conforms to our naming conventions...
+#
+if ARGV[0] !~ /\.dec$/ then
+  puts "The file to be encrypted (#{ARGV[0]}) MUST have the file extension '.dec'";
+  exit(-1);
+end
+
+# check to make sure the file exists...
+#
+if !File.exists?(ARGV[0]) then
+  puts "The file to be encrypted (#{ARGV[0]}) does not exist";
+  exit(-1);
+end
+
+# get the plain text...
+#
+plainText = File.open(ARGV[0]).read;
+
+# Ensure the configuration has been loaded...
+Rake.application.raw_load_rakefile;
+
+# encrypt the file...
+#
+begin
+  gpgEncryptData2File(plainText, ARGV[0].sub(/\.dec/,'.enc'));
+rescue CookEncryptionError => e
+  puts "Failed to encrypt using GnuPG";
+  puts "(#{e.message})...";
+  puts "\ntrying OpenSSL...";
+  openSslEncryptData2File(plainText, ARGV[0].sub(/\.dec/,'.enc'));
+end
+
+##
+# Returns +true+ if the +program+ executable is found in the user's path.
+# Taken from: http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby/3380168#3380168
+#
+def has_program?(program)
+  ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
+    File.executable?(File.join(directory, program.to_s))
+  end
+end
+
+if File.exists?(ARGV[0]) then
+  if has_program?('srm') then
+    puts "srm (secure remove) may require more entropy... so please move the mouse";
+    system("srm -v #{ARGV[0]}");
+  else
+    puts "if you had 'srm' installed then we could more securely remove the decrypted passwords in the file #{ARGV[0]}";
+    system ("rm #{ARGV[0]");
+  end
+end

data/lib/cook.rb

@@ -0,0 +1,3 @@
+class Cook
+  VERSION = '2.0.1'
+end

data/lib/rake/config.rb

@@ -0,0 +1,642 @@
+
+begin
+  require 'rubygems';
+  gem 'construct';
+rescue LoadError
+end
+
+require 'construct';
+require 'yaml';
+require 'fileutils';
+#require 'regexp';
+
+class Construct
+
+  def empty?()
+    @data.empty?();
+  end
+
+  def has_key?(key)
+    @data.has_key?(key);
+  end
+
+  def each_pair(*args, &block)
+    @data.each_pair(*args, &block)
+  end
+
+  def each_key(*args, &block)
+    @data.each_key(*args, &block)
+  end
+
+  alias_method :orig_key_value_assignment, :[]= ;
+  def []=(key, value)
+    value = Hash.new() if value.nil?;
+
+    if @data.include?(key) && @data[key].is_a?(Construct) && (value.is_a?(Hash) || value.is_a?(Construct)) then
+      value = @data[key].merge(value);
+    end
+    orig_key_value_assignment(key, value);
+  end
+
+  def merge(valueToMerge)
+    if valueToMerge.is_a?(Hash) || valueToMerge.is_a?(Construct) then
+      valueToMerge.each do | key, value |
+        key = key.to_sym;
+        if value.is_a?(Hash) || value.is_a?(Construct) then
+          self[key] = Construct.new() unless self.has_key?(key);
+          if !self[key].is_a?(Construct) then
+            raise ArgumentError, "attempting to merge a Hash/Construct into an existing non Hash/Construct key [#{key}]";
+          end
+          self[key].merge(value);
+        elsif value.is_a?(Array) then
+          self[key] = Array.new() unless self.has_key?(key);
+          if !self[key].is_a?(Array) then
+            raise ArgumentError, "attempting to merge an Array into an existing non Array key [#{key}]";
+          end
+          value.each do | item |
+            self[key].push(item);
+          end
+        else
+          self[key] = value;
+        end
+      end
+    end
+    if valueToMerge.is_a?(Construct) then
+      @schema.merge(valueToMerge.schema);
+    end
+    return self;
+  end
+
+  def to_stringHash() 
+    result = Hash.new();
+    data.each_pair do | aKey, aValue |
+      if aValue.is_a?(Construct) then
+        aValue = aValue.to_stringHash();
+      end
+      result[aKey.to_s] = aValue;
+    end
+    return result;
+  end
+  
+end
+
+class ConfigurationError < StandardError
+end
+
+class ResourceNotFoundError < StandardError
+end
+
+class Conf
+
+  @@data = Construct.new();
+  @@encryptedData = Construct.new();
+  @@passPhrase = nil;
+  @@configFileNames = Array.new();
+  @@recipePaths = Array.new();
+
+  def self.get_pass_phrase(check = false)
+    if @@passPhrase.nil? then
+      require 'highline';
+      @@passPhrase = HighLine.new.ask("Pass phrase for encrypted configuration:") { | q | q.echo='*'; }
+      while check do
+        secondPassPhrase = HighLine.new.ask("Pass phrase (again):") { | q | q.echo='*'; }
+        if @@passPhrase != secondPassPhrase then
+          puts "The pass phrases do not match... please try again\n\n";
+          @@passPhrase = HighLine.new.ask("Pass phrase for encrypted configuration:") { | q | q.echo='*'; }
+        else
+          check = false;
+        end
+      end
+    end
+    @@passPhrase;
+  end
+
+  def self.data
+    return @@data;
+  end
+
+  def self.encryptedData
+    return @@encryptedData;
+  end
+
+  def self.has_key?(aKey)
+    return @@data.has_key?(aKey);
+  end
+
+  def self.has_encrypted_key?(aKey)
+    return @@encryptedData.has_key?(aKey);
+  end
+
+  def self.load(yaml)
+    loadedHash = YAML::load(yaml);
+    if loadedHash then
+      @@data.merge(loadedHash);
+    end
+  end
+
+  def self.load_file(yamlFileName)
+    Rake::Application.mesg "loading configuration file [#{yamlFileName}]\n  in #{Dir.getwd}" if Rake.application.options.trace;
+    loadedHash = YAML::load_file(yamlFileName);
+    if loadedHash then
+      @@data.merge(loadedHash);
+    end
+  end
+
+  def self.load_encrypted_file(yamlFileName)
+    Rake::Application.mesg "loading encrypted configuration file [#{yamlFileName}]\n  in #{Dir.getwd}" if Rake.application.options.trace;
+    yamlPlainText = "";
+    begin 
+      yamlPlainText = gpgDecryptFile2Data(yamlFileName);
+    rescue
+      yamlPlainText = openSslDecryptFile2Data(yamlFileName);
+    end
+    loadedHash = YAML::load(yamlPlainText);
+    if loadedHash then
+      @@encryptedData.merge(loadedHash);
+    end
+  end
+
+  def self.save_file(yamlFileName, branch = [])
+    branchData = @@data;
+    branch.each do | aKey |
+      branchData = branchData[aKey] if branchData.has_key?(aKey);
+    end
+    branchData = branchData.to_stringHash if branchData.is_a?(Construct);
+    branch.reverse.each do | aKey |
+      tmpHash = Hash.new();
+      tmpHash[aKey.to_s] = branchData;
+      branchData = tmpHash;
+    end
+    yamlFile = File.open(yamlFileName, "w");
+    YAML::dump(branchData, yamlFile);
+    yamlFile.close();
+  end
+
+  def self.method_missing(meth, *args)
+    meth_s = meth.to_s
+    if @@data.respond_to?(meth) ||
+      @@data.data.has_key?(meth) ||
+      @@data.schema.has_key?(meth) ||
+      meth_s[-1..-1] == '='then
+      @@data.method_missing(meth, *args);
+    else 
+      raise ConfigurationError, "No configuation value specified for Conf[#{meth.to_s}]";
+    end
+  end
+
+  def self.add_config_file_name(configFileName)
+    configFileName.sub!(/\.[^\.]*$/,'');
+    Rake::Application.mesg "Adding config name: [#{configFileName}]";
+    @@configFileNames.push(configFileName);
+  end
+
+  def self.load_config_files(recipeDir)
+    @@configFileNames.each() do  | aConfigFileName |
+      #
+      # load the yaml configuration file
+      #
+      confFile = recipeDir + '/' + aConfigFileName + '.conf';
+      self.load_file(confFile) if File.exists?(confFile);
+      encConfFile = recipeDir + '/' + aConfigFileName + '.enc';
+      self.load_encrypted_file(encConfFile) if File.exists?(encConfFile);
+    end
+  end
+
+  def self.load_rake_files(recipeDir)
+    @@configFileNames.each() do | aConfigFileName |
+      #
+      # load the corresponding rake file
+      #
+      rakeFile = recipeDir + '/' + aConfigFileName + '.rake';
+      Rake.load_rakefile(rakeFile) if File.exists?(rakeFile);
+    end
+  end
+
+  def self.add_recipes_path(aRecipesPath)
+    @@recipePaths.push(aRecipesPath);
+  end
+
+  def self.get_recipe_paths()
+    @@recipePaths;
+  end
+
+  def self.find_resource(aPartialResourcePath)
+    @@recipePaths.each do | aRecipePath |
+      aResourcePath = aRecipePath+aPartialResourcePath;
+      return aResourcePath if File.exists?(aResourcePath);
+    end
+    raise ResourceNotFoundError, "Resource file #{aPartialResourcePath} could not be found";
+  end
+
+  def self.each_resource(aPartialResourcePath, &aBlock)
+    @@recipePaths.each do | aRecipePath |
+      aResourcePath = aRecipePath+aPartialResourcePath;
+      next unless File.exists?(aResourcePath);
+      aBlock.call(aResourcePath);
+    end
+  end
+
+  def self.add_cookbook(aCookbookPath)
+    $LOAD_PATH.unshift(aCookbookPath+'/lib');
+    Conf.add_recipes_path(aCookbookPath+'/');
+    Conf.add_recipes_path(aCookbookPath+'/recipes/');
+#    Dir.chdir(aCookbookPath) do
+      #
+      # load the cookbook configuration file first incase they are used 
+      # in the rakefile
+      confFile = aCookbookPath + '/' + 'cookbook.conf';
+      Conf.load_file(confFile) if File.exists?(confFile);
+      encConfFile = aCookbookPath + '/' + 'cookbook.enc';
+      Conf.load_encrypted_file(encConfFile) if File.exists?(encConfFile);
+
+      # now load the corresponding cookbook rake file
+      rakeFile = aCookbookPath + '/' + 'cookbook.rake';
+      Rake.load_rakefile(rakeFile) if File.exists?(rakeFile);
+#    end
+  end
+
+  def self.log_file_name()
+    return @@configFileNames.join('-') unless @@configFileNames.empty?;
+    return "noConfig";
+  end
+
+  def self.load_recipe_dir(recipeDir)
+    #
+    # extract the last directory name in the path to use as the 
+    # recipeName
+    #
+    recipeName = recipeDir.split(/\//).pop();
+    #
+    # search for sub-directories and recursively calling 
+    # load_recipe_dir to load any *.conf/*.enc or *.rake fragments 
+    # found.
+    #
+    Dir.glob(recipeDir+'/*').each do | aFileName |
+      next unless aFileName.dup.force_encoding("UTF-8").valid_encoding?
+      next if aFileName =~ /\.$/;
+      next unless File.directory?(aFileName);
+      load_recipe_dir(aFileName);
+    end
+    #
+    # load the configurtion files first in case they are used in the 
+    # rakefile
+    # ... generic first ...
+    confFile = recipeDir + '/' + recipeName + '.conf';
+    Conf.load_file(confFile) if File.exists?(confFile);
+    encConfFile = recipeDir + '/' + recipeName + '.enc';
+    Conf.load_encrypted_file(encConfFile) if File.exists?(encConfFile);
+    # ... then more specific ...
+    Conf.load_config_files(recipeDir);
+
+    # now load the corresponding rake files
+    # ... generic first...
+    rakeFile = recipeDir + '/' + recipeName + '.rake';
+    Rake.load_rakefile(rakeFile) if File.exists?(rakeFile);
+    # ... then more specific ...
+    Conf.load_rake_files(recipeDir);
+  end
+
+  def self.load_recipe(recipeName)
+    @@recipePaths.reverse.each do | aRecipePath |
+      recipeDir = aRecipePath+recipeName;
+      next unless File.directory?(recipeDir);
+      load_recipe_dir(recipeDir);
+    end
+  end
+
+  def self.load_central_config_files()
+    @@recipePaths.reverse.each do | aRecipePath |
+      load_config_files(aRecipePath.sub(/\/$/,''));
+    end
+  end
+
+end
+
+module Rake
+
+  class <<self 
+    alias_method :rake_config_original_load_rakefile, :load_rakefile
+    def load_rakefile(*args)
+      Rake::Application.mesg "Loading rakefile [#{args[0]}]\n  in #{Dir.getwd}" if Rake.application.options.trace;
+      rake_config_original_load_rakefile(*args);
+    end
+  end
+
+  class Application
+
+    alias_method :rake_config_original_standard_rake_options, :standard_rake_options ;
+    def standard_rake_options
+      options = rake_config_original_standard_rake_options();
+      options.push(
+        ['--config', '-c YAML-CONFIG-FILE-NAME', "Load YAML configuration files named YAML-CONFIG-FILE-NAME in each receipe if it exists", 
+          lambda { |value|
+            confValues = value.split(/,/).each do | aValue |
+              Conf.add_config_file_name(aValue);
+            end
+          }
+        ]);
+      return options;
+    end
+
+    alias_method :rake_config_original_collect_tasks, :collect_tasks
+    def collect_tasks
+      rake_config_original_collect_tasks;
+      @top_level_tasks.unshift("cookPostConfig");
+      @top_level_tasks.unshift("cookConfig");
+      @top_level_tasks.unshift("cookPreConfig");
+    end
+
+    alias_method :rake_config_original_top_level, :top_level
+    def top_level
+      # load the central config files after all recipes
+      Conf.load_central_config_files(); 
+      # but before we start invoking tasks
+      rake_config_original_top_level;
+    end
+
+    def raw_load_rakefile
+      myCookbookDir = File.expand_path(Dir.getwd());
+      FileUtils.mkdir_p('logs');
+      Rake::Application.openLogger('logs/'+Conf.log_file_name.gsub(/\//,'_')+'-buildLog');
+      Rake::Application.logger.level = Logger::DEBUG;
+      Rake::Application.mesg "Building in #{myCookbookDir}";
+      Conf.add_cookbook(myCookbookDir);
+    end
+
+  end
+
+  class Task
+
+    # Execute the rsync command on the arguments provided using greenletters.
+    def self.scp_to_remote_scp(localPath, remotePath, options = {}, &aBlock)
+      options = Conf.scp.data.merge(options);
+      options[:timeout] = 10 unless options.has_key?(:timeout);
+      cmd     = [options[:command], 
+                 options[:cmdOptions], 
+                 localPath,
+                 "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
+                ].flatten
+
+      gl_run(*cmd, options, &aBlock);
+    end
+
+    # Execute the rsync command on the arguments provided using greenletters.
+    def self.scp_from_remote(remotePath, localPath, options = {}, &aBlock)
+      options = Conf.scp.data.merge(options);
+      options[:timeout] = 10 unless options.has_key?(:timeout);
+      cmd     = [options[:command], 
+                 options[:cmdOptions], 
+                 "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
+                 localPath,
+                ].flatten
+
+      gl_run(*cmd, options, &aBlock);
+    end
+
+    # Execute the rsync command on the arguments provided using greenletters.
+    def self.rsync_to_remote(localPath, remotePath, options = {}, &aBlock)
+      if localPath =~ /\*/ then
+        localPath = Dir.glob(localPath);
+      end
+      options = Conf.rsync.data.merge(options);
+      options[:timeout] = 10 unless options.has_key?(:timeout);
+      cmd     = [options[:command], 
+                 options[:cmdOptions], 
+                 localPath,
+                 "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
+                ].flatten
+
+      gl_run(*cmd, options, &aBlock);
+    end
+
+    # Execute the rsync command on the arguments provided using greenletters.
+    def self.rsync_from_remote(remotePath, localPath, options = {}, &aBlock)
+      options = Conf.rsync.data.merge(options);
+      options[:timeout] = 10 unless options.has_key?(:timeout);
+      cmd     = [options[:command], 
+                 options[:cmdOptions], 
+                 "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
+                 localPath,
+                ].flatten
+
+      gl_run(*cmd, options, &aBlock);
+    end
+
+    # Execute +command+ using ssh to remote_host using greenletters.
+    def self.remote_ssh(*args, &aBlock)
+      options = if args.last.is_a?(Hash) then args.pop else {} end
+      options = Conf.ssh.data.merge(options);
+      options[:timeout] = 10 unless options.has_key?(:timeout);
+      sshPort = Array.new();
+      sshPort = [ '-p', options[:remotePort]] if options.has_key?(:remotePort);
+      cmd     = [options[:command], 
+                 options[:cmdOptions], 
+                 '-l',
+                 options[:userId],
+                 sshPort,
+                 options[:remoteHost]
+                ].flatten
+
+      gl_run(*cmd, options) do | p |
+        p.wait_for(:output, Regexp.new(options[:commandPromptRegExp]));
+        Rake::Application.mesg args.flatten.join(' ') if Rake.application.options.trace;
+        p.puts args.flatten.join(' ') + '; exit';
+      end
+    end
+
+    # Execute +command+ using sh on local_host using greenletters.
+    def self.local_sh(*args, &aBlock)
+      options = if args.last.is_a?(Hash) then args.pop else {} end
+      options = Conf.sh.data.merge(options);
+      cmd     = [options[:command], 
+                 options[:cmdOptions],
+                 "-c", 
+                 args.flatten.join(' ')
+                ].flatten
+
+      gl_run(*cmd, options, &aBlock);
+    end
+
+    # Execute +command+ (as is) on local_host using greenletters to 
+    # enable expect like behaviour (useful for dealling with 
+    # passwords).
+    def self.gl_run(*args, &aBlock)
+      $TRACE = Rake.application.options.trace;
+
+      options = Hash.new;
+      if args.last.is_a?(Construct) then 
+        raise ConfigurationError, "gl_run should not be passed a Construct";
+      elsif args.last.is_a?(Hash)
+        options = args.pop;
+      end
+      Conf.timeout = Hash.new() unless Conf.has_key?(:timeout);
+      Conf.timeout.maxTimeout = 10 unless Conf.timeout.has_key?(:maxTimeout);
+      if options.has_key?(:timeout) then
+        options[:timeout] = Conf.timeout.maxTimeout if Conf.timeout.maxTimeout.to_i < options[:timeout].to_i ;
+      else
+        options[:timeout] = 10;
+      end
+
+      Rake::Application.mesg args.join(' ') if $TRACE
+      Rake::Application.mesg "#{options}" if $TRACE && !options.empty?() && options.has_key?(:verbose);
+
+      asyncTriggersBlocks = Array.new;
+      if options.has_key? :asyncTriggersBlocks then
+        asyncTriggersBlocks = options[:asyncTriggersBlocks];
+      end
+
+      exitStatus = 0;
+      if options.has_key? :exitStatus then
+        exitStatus = options[:exitStatus];
+      end
+
+      options[:env] = ENV unless options.has_key?(:env);
+      options[:transcript] = Rake::Application.logger unless options.has_key?(:transcript);
+
+      cmdProcess = Greenletters::Process.new(*args, options);
+      cmdProcess.start!;
+
+      asyncTriggersBlocks.each do | asyncTriggersBlock |
+        if asyncTriggersBlock.kind_of? Proc then
+          asyncTriggersBlock.call(cmdProcess);
+        end
+      end
+
+      aBlock.call(cmdProcess) unless aBlock.nil?;
+
+      cmdProcess.wait_for(:exit, exitStatus);
+
+      cmdProcess
+    end
+
+  end
+
+  module DSL
+
+    def config(*args, &block)
+      Rake::Task.define_task(*args, &block);
+    end
+
+    def load_recipe(recipeName)
+      Conf.load_recipe(recipeName);
+    end
+
+    def add_cookbook(aCookbookPath)
+      Conf.add_cookbook(aCookbookPath);
+    end
+
+    def find_resource(aPartialResourcePath)
+      Conf.find_resource(aPartialResourcePath);
+    end
+
+    def read_resource(aPartialResourcePath)
+      File.open(Conf.find_resource(aPartialResourcePath)).read;
+    end
+
+    def each_resource(aPartialResourcePath, &aBlock)
+      Conf.each_resource(aPartialResourcePath, &aBlock);
+    end
+
+    def set_command_options(commandSymbols, options = {}, &asyncTriggersBlock)
+      commandSymbols = [ :local, :remote ] if commandSymbols == :all;
+      commandSymbols = [ :local, :remote ] if commandSymbols.kind_of? Array and commandSymbols.include? :all;
+      commandSymbols = [ commandSymbols ] unless commandSymbols.kind_of? Array;
+      commandSymbols.push(:sh).flatten! if commandSymbols.include?(:local);
+      commandSymbols.push([:scp, :ssh, :rsync]).flatten! if commandSymbols.include?(:remote);
+      commandSymbols.each do | aCommandSymbol |
+        aCommandSymbol = aCommandSymbol.to_sym;
+        next if aCommandSymbol == :all;
+        next if aCommandSymbol == :local;
+        next if aCommandSymbol == :remote;
+        if !Conf.data.has_key?(aCommandSymbol) then
+          Conf.data[aCommandSymbol] = Hash.new;
+          Conf.data[aCommandSymbol].command = aCommandSymbol.to_s;
+          Conf.data[aCommandSymbol].cmdOptions = Array.new;
+          Conf.data[aCommandSymbol].commandPromptRegExp = '.';
+          Conf.data[aCommandSymbol].asyncTriggersBlocks = Array.new;
+        end
+        Conf.data[aCommandSymbol].merge(options);
+        Conf.data[aCommandSymbol].asyncTriggersBlocks.push(asyncTriggersBlock);
+      end
+    end
+
+    def local_sh(*args, &block)
+      Rake::Task.local_sh(*args, &block);
+    end
+
+    def local_run(*args, &block)
+      Rake::Application.mesg "Use of local_run is depreciated. Please use local_sh instead";
+      Rake::Task.local_sh(*args, &block);
+    end
+
+    def remote_ssh(*args, &block)
+      Rake::Task.remote_ssh(*args, &block);
+    end
+
+    def remote_run(*args, &block)
+      Rake::Application.mesg "Use of remote_run is depreciated. Please use remote_ssh instead";
+      Rake::Task.remote_ssh(*args, &block);
+    end
+
+    def scp_to_remote(localPath, remotePath, options = {}, &block)
+      Rake::Task.scp_to_remote(localPath, remotePath, options &block);
+    end
+
+    def scp_from_remote(remotePath, localPath, options = {}, &block)
+      Rake::Task.scp_from_remote(remotePath, localPath, options, &block);
+    end
+
+    def rsync_to_remote(localPath, remotePath, options = {}, &aBlock)
+      Rake::Task.rsync_to_remote(localPath, remotePath, options, &aBlock);
+    end
+
+    def rsync_from_remote(remotePath, localPath, options = {}, &aBlock)
+      Rake::Task.rsync_from_remote(remotePath, localPath, options, &aBlock);
+    end
+
+  end
+
+end
+
+self.extend Rake::DSL
+
+
+# Ensure the configuration for the sh, scp, ssh and rsync commands are setup
+#Conf.sh = Hash.new;
+#Conf.sh.command = "sh";
+#Conf.sh.cmdOptions = Array.new;
+#Conf.ssh = Hash.new;
+#Conf.ssh.command = "ssh";
+#Conf.ssh.cmdOptions = Array.new;
+#Conf.scp = Hash.new;
+#Conf.scp.command = "scp";
+#Conf.scp.cmdOptions = Array.new;
+#Conf.rsync = Hash.new;
+#Conf.rsync.command = "rsync";
+#Conf.rsync.cmdOptions = Array.new;
+set_command_options(:all);
+
+# Ensure the gpg hash exists (but may be empty)
+Conf.gpg = Hash.new;
+
+$LOAD_PATH.push('.');
+
+config :cookPreConfig do
+  Rake::Application.mesg "finished (cook) preConfig stage\n\n";
+end
+
+config :cookConfig do
+  Rake::Application.mesg "finished (cook) config stage\n\n";
+end
+
+config :cookPostConfig do
+  Rake::Application.mesg "finished (cook) postConfig stage\n\n";
+  if Rake.application.options.trace then
+    Rake::Application.mesg "--------------------\nTasks defined\n\n";
+    Rake::Application.mesg_pp Rake.application.tasks;
+    Rake::Application.mesg "--------------------\nConfiguration data\n\n";
+    Rake::Application.mesg_pp Conf.data;
+    Rake::Application.mesg "--------------------\n\n";
+  end
+end
+