the-maestro 0.2.0

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/maestro.rb

@@ -0,0 +1,354 @@
+require "maestro/dsl_property"
+require "find"
+require "ftools"
+require "maestro/cloud"
+require "maestro/cloud/aws"
+require "maestro/operating_system"
+require "log4r"
+require "log4r/configurator"
+require "maestro/log4r/console_formatter"
+
+
+def aws_cloud(name, &block)
+  Maestro::Cloud::Aws.new(name, &block)
+end
+
+
+module Maestro
+
+  # ENV key used to point to a Maestro configuration directory
+  MAESTRO_DIR_ENV_VAR = 'MAESTRO_DIR'
+
+  # Directory underneath RAILS_ROOT where Maestro expects to find config files
+  MAESTRO_RAILS_CONFIG_DIRECTORY = '/config/maestro'
+
+  # Directory underneath RAILS_ROOT where Maestro log files will be written
+  MAESTRO_RAILS_LOG_DIRECTORY = '/log/maestro'
+
+  # Name of the Maestro Chef assets archive
+  MAESTRO_CHEF_ARCHIVE = 'maestro_chef_assets.tar.gz'
+
+  # add a PROGRESS level
+  Log4r::Configurator.custom_levels(:DEBUG, :INFO, :PROGRESS, :WARN, :ERROR, :FATAL)
+  @logger = Log4r::Logger.new("maestro")
+  outputter = Log4r::Outputter.stdout
+  outputter.formatter = ConsoleFormatter.new
+  @logger.add(outputter)
+
+
+  # Creates the Maestro config directory structure. If the directories already exist, no action is taken.
+  #
+  # In a Rails environment:
+  #
+  #     RAILS_ROOT/config/maestro
+  #     RAILS_ROOT/config/maestro/clouds
+  #     RAILS_ROOT/config/maestro/cookbooks
+  #     RAILS_ROOT/config/maestro/roles
+  #
+  # In a standalone environment, the following directories will be created under
+  # the directory specified by the ENV['MAESTRO_DIR'] environment variable:
+  #
+  #     MAESTRO_DIR/config/maestro
+  #     MAESTRO_DIR/config/maestro/clouds
+  #     MAESTRO_DIR/config/maestro/cookbooks
+  #     MAESTRO_DIR/config/maestro/roles
+  def self.create_config_dirs
+    if defined? RAILS_ROOT
+      create_configs(rails_config_dir)
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      create_configs(standalone_config_dir)
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+  end
+
+  # Creates the Maestro log directories. If the directories already exist, no action is taken.
+  #
+  # In a Rails environment:
+  #
+  #     RAILS_ROOT/log/maestro
+  #     RAILS_ROOT/log/maestro/clouds
+  #
+  # In a standalone environment, the following directories will be created under
+  # the directory specified by the ENV['MAESTRO_DIR'] environment variable:
+  #
+  #     MAESTRO_DIR/log/maestro
+  #     MAESTRO_DIR/log/maestro/clouds
+  def self.create_log_dirs
+    if defined? RAILS_ROOT
+      create_logs(rails_log_dir)
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      create_logs(standalone_log_dir)
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+  end
+
+  # Validates your maestro configs. This method returns an Array with two elements:
+  # * element[0] boolean indicating whether your maestro configs are valid
+  # * element[1] Array of Strings containing a report of the validation
+  def self.validate_configs
+    if defined? RAILS_ROOT
+      validate_rails_config
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      validate_standalone_config
+    else
+      return [false, ["Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"]]
+    end
+  end
+
+  # Returns a Hash of Clouds defined in the Maestro clouds configuration directory
+  def self.clouds
+    if defined? RAILS_ROOT
+      get_clouds(clouds_config_dir(rails_maestro_config_dir))
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      get_clouds(clouds_config_dir(standalone_maestro_config_dir))
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+  end
+
+  # Returns the top level log directory
+  def self.log_directory
+    if defined? RAILS_ROOT
+      rails_log_dir
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      standalone_log_dir
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+  end
+
+  # Returns the maestro log directory
+  def self.maestro_log_directory
+    if defined? RAILS_ROOT
+      rails_log_dir + "/maestro"
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      standalone_log_dir + "/maestro"
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+  end
+
+  # Creates a .tar.gz file containing the Chef cookbooks/ and roles/ directories within the maestro config directory, and returns the path to the file
+  def self.chef_archive
+    require 'tempfile'
+    require 'zlib'
+    require 'archive/tar/minitar'
+
+    dir = nil
+    if defined? RAILS_ROOT
+      dir = rails_maestro_config_dir
+    elsif ENV.has_key? MAESTRO_DIR_ENV_VAR
+      dir = standalone_maestro_config_dir
+    else
+      raise "Maestro not configured correctly. Either RAILS_ROOT or ENV['#{MAESTRO_DIR_ENV_VAR}'] must be defined"
+    end
+    temp_file = Dir.tmpdir + "/" + MAESTRO_CHEF_ARCHIVE
+    File.delete(temp_file) if File.exist?(temp_file)
+
+    pwd = Dir.pwd
+    open temp_file, 'wb' do |io|
+      Zlib::GzipWriter.wrap io do |gzip|
+        begin
+          out = Archive::Tar::Minitar::Output.new(gzip)
+          Dir.chdir(dir) # don't store full paths in archive
+          Dir.glob("cookbooks/**/**").each do |file|
+            Archive::Tar::Minitar.pack_file(file, out) if File.file?(file) || File.directory?(file) 
+          end
+          Dir.glob("roles/**/**").each do |file|
+            Archive::Tar::Minitar.pack_file(file, out) if File.file?(file) || File.directory?(file) 
+          end
+        ensure
+          gzip.finish
+        end
+      end
+    end
+    Dir.chdir(pwd)
+    temp_file
+  end
+
+
+  private
+
+  # Creates the Maestro config directory structure in the given directory
+  #
+  # - dir: The base directory in which to create the maestro config directory structure
+  def self.create_configs(dir)
+    raise "Cannot create Maestro config directory structure: #{dir} doesn't exist." if !File.exist?(dir)
+    raise "Cannot create Maestro config directory structure: #{dir} is not a directory." if !File.directory?(dir)
+    raise "Cannot create Maestro config directory structure: #{dir} is not writable." if !File.writable?(dir)
+    base_dir = dir
+    base_dir.chop! if base_dir =~ /\/$/
+    if !File.exist?("#{base_dir}/maestro")
+      Dir.mkdir("#{base_dir}/maestro")
+      @logger.progress "Created #{base_dir}/maestro"
+    end
+    if !File.exist?("#{base_dir}/maestro/clouds")
+      Dir.mkdir("#{base_dir}/maestro/clouds")
+      @logger.info "Created #{base_dir}/maestro/clouds"
+    end
+    if !File.exist?("#{base_dir}/maestro/cookbooks")
+      Dir.mkdir("#{base_dir}/maestro/cookbooks")
+      @logger.info "Created #{base_dir}/maestro/cookbooks"
+    end
+    if !File.exist?("#{base_dir}/maestro/roles")
+      Dir.mkdir("#{base_dir}/maestro/roles")
+      @logger.info "Created #{base_dir}/maestro/roles"
+    end
+  end
+
+  # Creates the Maestro config directory structure in the given directory
+  #
+  # - dir: The base directory in which to create the maestro log directory structure
+  def self.create_logs(dir)
+    raise "Cannot create Maestro log directory: #{dir} doesn't exist." if !File.exist?(dir)
+    raise "Cannot create Maestro log directory: #{dir} is not a directory." if !File.directory?(dir)
+    raise "Cannot create Maestro log directory: #{dir} is not writable." if !File.writable?(dir)
+    begin
+      base_dir = dir
+      base_dir.chop! if base_dir =~ /\/$/
+      if !File.exist?("#{base_dir}/maestro")
+        Dir.mkdir("#{base_dir}/maestro")
+        @logger.info "Created #{base_dir}/maestro"
+      end
+      if !File.exist?("#{base_dir}/maestro/clouds")
+        Dir.mkdir("#{base_dir}/maestro/clouds")
+        @logger.info "Created #{base_dir}/maestro/clouds"
+      end
+    rescue SystemCallError => syserr
+      @logger.error "Error creating cloud directory"
+      @logger.error syserr
+    rescue StandardError => serr
+      @logger.error "Unexpected Error"
+      @logger.error serr
+    end
+  end
+
+  # Validates the maestro configuration found at RAILS_ROOT/config/maestro
+  def self.validate_rails_config
+    validate_config rails_maestro_config_dir
+  end
+
+  # Validates the maestro configuration found at ENV['MAESTRO_DIR']
+  def self.validate_standalone_config
+    validate_config standalone_maestro_config_dir
+  end
+
+  # Validates the maestro configuration found at the given maestro_directory
+  def self.validate_config(maestro_directory)
+    valid = true
+    error_messages = Array.new
+    if !File.exist?(maestro_directory)
+      valid = false
+      error_messages << "Maestro config directory does not exist: #{maestro_directory}"
+    end
+    if !File.directory?(maestro_directory)
+      valid = false
+      error_messages << "Maestro config directory is not a directory: #{maestro_directory}"
+    end
+    clouds_directory = clouds_config_dir maestro_directory
+    if !File.exist?(clouds_directory)
+      valid = false
+      error_messages << "Maestro clouds config directory does not exist: #{clouds_directory}"
+    end
+    if !File.directory?(clouds_directory)
+      valid = false
+      error_messages << "Maestro clouds config directory is not a directory: #{clouds_directory}"
+    end
+    cookbooks_directory = cookbooks_dir maestro_directory
+    if !File.exist?(cookbooks_directory)
+      valid = false
+      error_messages << "Chef cookbooks directory does not exist: #{cookbooks_directory}"
+    else
+      if !File.directory?(cookbooks_directory)
+        valid = false
+        error_messages << "Chef cookbooks directory is not a directory: #{cookbooks_directory}"
+      end
+    end
+    roles_directory = roles_dir maestro_directory
+    if !File.exist?(roles_directory)
+      valid = false
+      error_messages << "Chef roles directory does not exist: #{roles_directory}"
+    else
+      if !File.directory?(roles_directory)
+        valid = false
+        error_messages << "Chef roles directory is not a directory: #{roles_directory}"
+      end
+    end
+    if valid
+      clouds = get_clouds(clouds_directory)
+      clouds.each do |name, cloud|
+        cloud.validate
+        if !cloud.valid?
+          valid = false
+          error_messages << "INVALID: #{cloud.config_file}"
+          cloud.validation_errors.each {|error| error_messages << "    #{error}"}
+        else
+          error_messages << "VALID: #{cloud.config_file}"
+        end
+      end
+    end
+    return [valid, error_messages]
+  end
+
+  def self.rails_config_dir
+    "#{RAILS_ROOT}/config"
+  end
+
+  def self.rails_log_dir
+    "#{RAILS_ROOT}/log"
+  end
+
+  def self.rails_maestro_config_dir
+    "#{RAILS_ROOT}#{MAESTRO_RAILS_CONFIG_DIRECTORY}"
+  end
+
+  def self.standalone_maestro_config_dir
+    "#{ENV[MAESTRO_DIR_ENV_VAR]}#{MAESTRO_RAILS_CONFIG_DIRECTORY}"
+  end
+
+  def self.standalone_config_dir
+    "#{ENV[MAESTRO_DIR_ENV_VAR]}/config"
+  end
+
+  def self.standalone_log_dir
+    "#{ENV[MAESTRO_DIR_ENV_VAR]}/log"
+  end
+
+  def self.clouds_config_dir(maestro_directory)
+    "#{maestro_directory}/clouds"
+  end
+
+  def self.cookbooks_dir(maestro_directory)
+    "#{maestro_directory}/cookbooks"
+  end
+
+  def self.roles_dir(maestro_directory)
+    "#{maestro_directory}/roles"
+  end
+
+  # Gets the Hash of Clouds found in clouds_directory
+  def self.get_clouds(clouds_directory)
+    clouds_directory << "/" unless clouds_directory =~ /\/$/
+    clouds = {}
+    config_files = get_cloud_config_files(clouds_directory)
+    config_files.each do |config_file|
+      cloud_name = config_file[clouds_directory.length, (config_file.length-(clouds_directory.length+File.extname(config_file).length))]
+      cloud = Cloud::Base.create_from_file(config_file)
+      clouds[cloud_name] = cloud
+    end
+    clouds
+  end
+
+  # Returns and array of all Cloud files found in clouds_directory
+  def self.get_cloud_config_files(clouds_directory)
+    config_files = []
+    Find.find(clouds_directory) do |path|
+      if FileTest.file?(path) && (File.extname(path).eql?(".rb"))
+        config_files << path
+      end
+    end
+    config_files
+  end
+end

data/lib/maestro/cloud.rb

@@ -0,0 +1,384 @@
+require "ftools"
+require "maestro/role"
+require "maestro/node"
+require 'maestro/validator'
+require "net/ssh/multi"
+require "log4r"
+require "maestro/log4r/console_formatter"
+require "maestro/log4r/file_formatter"
+
+
+module Maestro
+  # A named cloud (i.e. production, staging, test, dev, etc)
+  module Cloud
+    class Base
+      include Validator
+
+      # the name of this cloud
+      attr_reader :name
+      # the config file for this cloud
+      attr_accessor :config_file
+      # the Hash of Configurable Nodes in this Cloud
+      attr_reader :configurable_nodes
+      # String containing the full path to this Cloud's log directory
+      attr_reader :log_directory
+      dsl_property :keypair_name, :keypair_file
+
+      # Creates a new Cloud object.
+      # * name: the name of the Cloud
+      # * cfg_file: Pointer to the file containing the Cloud configuration (optional)
+      # * block: contents of the Cloud
+      def initialize(name, cfg_file=nil, &block)
+        super()
+        raise StandardError, "Cloud name cannot contain spaces: #{name}" if name.is_a?(String) && !name.index(/\s/).nil?
+        @name = name
+        @config_file = cfg_file
+        @roles = Hash.new
+        @nodes = Hash.new
+        @configurable_nodes = Hash.new
+        @valid = true
+        @logger = Log4r::Logger.new(Regexp::quote(@name.to_s))
+        outputter = Log4r::StdoutOutputter.new("#{@name.to_s}-stdout")
+        outputter.formatter = ConsoleFormatter.new
+        @logger.add(outputter)
+        init_logs
+        instance_eval(&block) if block_given?
+      end
+
+      # Creates a Cloud from the contents of the given file
+      def self.create_from_file(config_file)
+        cloud = eval(File.read(config_file))
+        cloud.config_file = config_file
+        return cloud
+      end
+
+      # creates the Roles for this Cloud if a block is given. Otherwise, returns the roles Hash
+      def roles(&block)
+        if block_given?
+          instance_eval(&block)
+        else
+          @roles
+        end
+      end
+
+      # sets the roles Hash
+      def roles=(roles)
+        @roles = roles
+      end
+
+      # creates a Role
+      def role(name, &block)
+        if @roles.has_key?(name)
+          invalidate "Duplicate role definition: #{name}"
+        else
+          @roles[name] = Role.new(name, self, &block)
+        end
+      end
+
+      # creates the Nodes for this Cloud if a block is given, otherwise returns the Nodes in this Cloud
+      def nodes(&block)
+        if block_given?
+          instance_eval(&block)
+        else
+          @nodes
+        end
+      end
+
+      # sets the nodes Hash
+      def nodes=(nodes)
+        @nodes = nodes
+      end
+
+      def method_missing(name, *params) #:nodoc:
+        @valid = false
+        @validation_errors << "Unexpected attribute: #{name}"
+      end
+
+      # Reports the current status of this Cloud
+      def status
+        @logger.info "#{@name} Cloud status:"
+        node_statuses
+      end
+
+      # Starts this Cloud. Takes no action if the Cloud is already running as currently configured
+      def start
+        @logger.info "Starting #{@name} Cloud. This may take a few minutes..."
+      end
+
+      # Configures the Nodes in this Cloud
+      def configure
+        @logger.info "Configuring #{@name} Cloud"
+        if !@configurable_nodes.empty?
+          session = open_ssh_session
+          result = chef_solo_installed?(session)
+          if !result[0]
+            names = result[1].collect {|n| n.name}
+            @logger.progress "Installing chef-solo on Nodes #{names.inspect}. This may take a few minutes..."
+            session.close
+            session = open_ssh_session(result[1])
+            install_chef_solo(session)
+            configure_chef_solo(session)
+            session.close
+            @logger.progress "\n"
+          else
+            @logger.info "chef-solo already installed on Nodes #{@configurable_nodes.keys.inspect}"
+          end
+          @logger.info "Running chef-solo on Nodes #{@configurable_nodes.keys.inspect}..."
+          session = open_ssh_session
+          run_chef_solo(session)
+          session.close
+          @logger.info "Configuration of #{@name} Cloud complete"
+        end
+      end
+
+      # Checks if chef-solo is installed on each of the Configurable Nodes in this Cloud.
+      # This method returns an Array with two elements:
+      # * element[0] boolean indicating whether chef-solo is installed on all Configurable Nodes 
+      # * element[1] Array of Nodes which need chef-solo installed
+      def chef_solo_installed?(session=nil)
+        close_session = false
+        if session.nil?
+          session = open_ssh_session
+          close_session = true
+        end
+        @logger.info "Checking for installation of chef-solo..."
+        valid = true
+        needs_chef = Array.new
+        session.open_channel do |channel|
+          # Find the node for this channel's host
+          the_node = nil
+          @configurable_nodes.each_pair {|name, node| the_node = node if channel[:host].eql? node.hostname}
+          if the_node.nil?
+            @logger.error "Could not find node matching hostname #{channel[:host]}. This should not happen."
+          else
+            channel.request_pty {|ch, success| abort "could not obtain pty" if !success}
+            channel.exec("chef-solo --version") do |ch, success|
+              ch.on_data do |ch, data|
+                if !data.include?("Chef: 0.8")
+                  valid = false
+                  needs_chef << the_node
+                end
+              end
+            end
+          end
+        end
+        session.loop(60)
+        session.close if close_session
+        return [valid, needs_chef]
+      end
+
+      # installs chef-solo on the Configurable Nodes the given session is set up with
+      def install_chef_solo(session=nil)
+        close_session = false
+        if session.nil?
+          session = open_ssh_session
+          close_session = true
+        end
+        etc_issue = nil
+        session.open_channel do |channel|
+          channel.request_pty {|ch, success| abort "could not obtain pty" if !success}
+          channel.exec("cat /etc/issue") do |ch, success|
+            ch.on_data {|ch, data| etc_issue = data}
+          end
+        end
+        session.loop(60)
+
+        # shut off the stdout outputter and only log to the nodes' log files
+        @configurable_nodes.each_pair {|name, node| node.disable_stdout}
+        os = Maestro::OperatingSystem.create_from_etc_issue(etc_issue)
+        os.chef_install_script.each do |cmd|
+          session.open_channel do |channel|
+            # Find the node for this channel's host
+            the_node = nil
+            @configurable_nodes.each_pair {|name, node| the_node = node if channel[:host].eql? node.hostname}
+            if the_node.nil?
+              @logger.error "Could not find node matching hostname #{channel[:host]}. This should not happen."
+            else
+              the_node.logger.info "Installing chef-solo"
+              channel.request_pty {|ch, success| abort "could not obtain pty" if !success}
+              channel.exec(cmd) do |ch, success|
+                @logger.progress "."
+                ch.on_data {|ch, data| the_node.logger.info data}
+                ch.on_extended_data {|ch, data| the_node.logger.error }
+              end
+            end
+          end
+          session.loop(60)
+        end
+        # turn the stdout outputter back on
+        @configurable_nodes.each_pair {|name, node| node.enable_stdout}
+        session.close if close_session
+      end
+
+      # configures chef-solo
+      def configure_chef_solo(session=nil)
+        close_session = false
+        if session.nil?
+          session = open_ssh_session
+          close_session = true
+        end
+        # write the chef-solo config file
+        chef_solo_config = 
+          ["sudo rm /tmp/chef-solo.rb",
+           "sudo mkdir -p /tmp/chef-solo",
+           "sudo mkdir -p /tmp/chef-solo/cookbooks",
+           "sudo mkdir -p /tmp/chef-solo/roles",
+           "sudo sh -c 'echo file_cache_path \\\"/tmp/chef-solo\\\" >> /tmp/chef-solo.rb'",
+           "sudo sh -c 'echo cookbook_path \\\"/tmp/chef-solo/cookbooks\\\" >> /tmp/chef-solo.rb'",
+           "sudo sh -c 'echo role_path \\\"/tmp/chef-solo/roles\\\" >> /tmp/chef-solo.rb'"]
+        chef_solo_config.each do |str|
+          session.open_channel do |channel|
+            channel.request_pty {|ch, success| abort "could not obtain pty" if !success}
+            channel.exec(str)
+          end
+          session.loop(60)
+        end
+        session.close if close_session
+      end
+
+      # runs chef-solo
+      def run_chef_solo(session=nil)
+        close_session = false
+        if session.nil?
+          session = open_ssh_session
+          close_session = true
+        end
+        commands = 
+           ["sudo chef-solo -c /tmp/chef-solo.rb -r '#{chef_assets_url()}'"]
+        # shut off the stdout outputter and only log to the nodes' log files
+        @configurable_nodes.each_pair {|name, node| node.disable_stdout}
+        commands.each do |cmd|
+          session.open_channel do |channel|
+            channel.request_pty {|ch, success| abort "could not obtain pty" if !success}
+            # Find the node for this channel's host
+            the_node = nil
+            @configurable_nodes.each_pair {|name, node| the_node = node if channel[:host].eql? node.hostname}
+            if the_node.nil?
+              @logger.error "Could not find node matching hostname #{channel[:host]}. This should not happen."
+            else
+              node_cmd = cmd + " -j '#{node_json_url(the_node)}'"
+              channel.exec(node_cmd) do |ch, success|
+                ch.on_data {|ch2, data2| the_node.logger.info data2}
+                ch.on_extended_data {|ch2, data2| the_node.logger.error data2}
+              end
+            end
+          end
+          session.loop(60)
+        end
+        # turn the stdout outputter back on
+        @configurable_nodes.each_pair {|name, node| node.enable_stdout}
+        session.close if close_session
+      end
+
+      # Shuts down this Cloud. Takes no action if the Cloud is not running
+      def shutdown
+        @logger.info "Shutting down #{@name} Cloud"
+      end
+
+
+      protected
+
+      # creates log directory and files for this cloud. If the log directory or files exist, no action is taken.
+      def init_logs
+        begin
+          if !File.exists?(Maestro.maestro_log_directory)
+            Maestro.create_log_dirs
+            @logger.info "Created #{Maestro.maestro_log_directory}"
+          end
+          clouds_dir = Maestro.maestro_log_directory + "/clouds"
+          if !File.exists?(clouds_dir)
+            Dir.mkdir(clouds_dir)
+            @logger.info "Created #{clouds_dir}"
+          end
+          cloud_dir = clouds_dir + "/#{@name}"
+          if !File.exists?(cloud_dir)
+            Dir.mkdir(cloud_dir)
+            @logger.info "Created #{cloud_dir}"
+          end
+          @log_directory = cloud_dir
+          cloud_log_file = cloud_dir + "/#{@name}.log"
+          if !File.exists?(cloud_log_file)
+            File.new(cloud_log_file, "a+")
+            @logger.info "Created #{cloud_log_file}"
+          end
+          outputter = Log4r::FileOutputter.new("#{@name}-file", :formatter => FileFormatter.new, :filename => cloud_log_file, :truncate => false)
+          @logger.add(outputter)
+        rescue RuntimeError => rerr
+          if !rerr.message.eql?("Maestro not configured correctly. Either RAILS_ROOT or ENV['MAESTRO_DIR'] must be defined")
+            @logger.error "Unexpected Error"
+            @logger.error rerr
+          end
+        rescue SystemCallError => syserr
+          @logger.error "Error creating cloud directory"
+          @logger.error syserr
+        rescue StandardError => serr
+          @logger.error "Unexpected Error"
+          @logger.error serr
+        end
+      end
+
+      # opens a multi ssh session. If the cnodes argument is nil, then a session
+      # is opened up to each Configurable Node in this Cloud. Otherwise, a session
+      # is opened to each Configurable Node in the cnodes array.
+      def open_ssh_session(cnodes=[])
+        handler = Proc.new do |server|
+          server[:connection_attempts] ||= 0
+          if server[:connection_attempts] < 50
+            server[:connection_attempts] += 1
+            sleep 2
+            throw :go, :retry
+          else
+            throw :go, :raise
+          end
+        end
+
+        session = Net::SSH::Multi.start(:concurrent_connections => 10, :on_error => handler)
+        if cnodes.empty?
+          @configurable_nodes.each_pair {|node_name, node| session.use node.hostname, :user => node.ssh_user, :keys => [keypair_file]}
+        else
+          cnodes.each {|node| session.use node.hostname, :user => node.ssh_user, :keys => [keypair_file]}
+        end
+        return session
+      end
+
+
+      private
+
+      # validates this Cloud
+      def validate_internal
+        invalidate "Missing keypair_name" if @keypair_name.nil?
+        invalidate "Missing keypair_file" if @keypair_file.nil?
+        validate_roles
+        validate_nodes
+      end
+
+      # validates the roles in the cloud config
+      def validate_roles
+        if @roles.nil? || @roles.empty?
+          invalidate "Missing roles"
+        else
+          @roles.each do |name, role|
+            role.validate
+            if !role.valid?
+              role.validation_errors.each {|error_str| invalidate error_str}
+            end
+          end
+        end
+      end
+
+      # validates the nodes in the cloud config
+      def validate_nodes
+        if @nodes.nil? || @nodes.empty?
+          invalidate "Missing nodes"
+        else
+          @nodes.each do |name, node|
+            node.validate
+            if !node.valid?
+              node.validation_errors.each {|error_str| invalidate error_str}
+            end
+          end
+        end
+      end
+    end
+  end
+end