Agiley-ec2onrails 0.9.9 → 0.9.10

data/server/files/usr/local/ec2onrails/lib/roles_helper.rb

@@ -0,0 +1,137 @@
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'net/http'
+require 'pp'
+require 'socket'
+require 'yaml'
+require 'erb'
+
+module Ec2onrails
+  module RolesHelper
+    ROLES_FILE = "/etc/ec2onrails/roles.yml"
+    MONGREL_CONF_FILE = "/etc/mongrel_cluster/app.yml"
+
+    def local_address
+      @local_address ||= get_address_metadata "local-ipv4"
+    end
+
+    def public_address
+      @public_address ||= get_address_metadata "public-ipv4"
+    end
+
+    def roles
+      @roles ||= resolve_all_addresses(YAML::load_file(ROLES_FILE))
+    end
+
+    def start(role, service, prog_name = service)
+      puts "STARTING #{role} role (service: #{service}, program_name: #{prog_name})"
+      # ensure script is executable
+      run "chmod a+x /etc/init.d/#{service}"
+      # start service if not running:
+      unless (system("pidof -x #{prog_name}"))
+        run "sh /etc/init.d/#{service} start && sleep 30" # give the service 30 seconds to start before attempting to monitor it
+      end
+      run "monit -g #{role} monitor all"
+    end
+
+    def stop(role, service, prog_name = service)
+      puts "STOPING #{role} role (service: #{service}, program_name: #{prog_name})"
+      run "monit -g #{role} unmonitor all"
+      if (system("pidof -x #{prog_name}"))
+        result = run("sh /etc/init.d/#{service} stop")
+      end  
+      # make start script non-executable in case of reboot
+      run("chmod a-x /etc/init.d/#{service}")
+    end
+
+    def run(cmd)
+      result = system(cmd)
+      puts("*****ERROR: #{cmd} returned #{$?}") unless result
+    end
+    
+    def sudo(cmd)
+      run("sudo #{cmd}")
+    end
+
+    def get_address_metadata(type)
+      address  = Net::HTTP.get('169.254.169.254', "/2007-08-29/meta-data/#{type}").strip
+      raise "couldn't get instance data: #{type}" unless address =~ /\A\d+\.\d+\.\d+\.\d+\Z/
+      # puts "#{type}: #{address}"
+      return address
+    end
+
+    def resolve(hostname)
+      address = IPSocket.getaddress(hostname).strip
+      if address == local_address || address == public_address
+        "127.0.0.1"
+      else
+        address
+      end
+    rescue Exception => e
+      puts "couldn't resolve hostname '#{hostname}'"
+      raise e
+    end
+
+    def resolve_all_addresses(original)
+      resolved = {}
+      original.each do |rolename, hostnames|
+        resolved[rolename] = hostnames.map{|hostname| resolve(hostname)} if hostnames
+      end
+      resolved
+    end
+
+    def in_role?(role)
+      return false unless roles[role]
+      return roles[role].include?("127.0.0.1") 
+    end
+    #to provide deprecated usage
+    alias :in_role :in_role?
+    
+
+    def add_etc_hosts_entry(entry_name, entry_addr)
+      host_file  = "/etc/hosts"
+      run("cp #{host_file}.original #{host_file}") unless File.exists?("#{host_file}.original")
+      hosts = File.read(host_file)
+      unless hosts =~ /\s+#{entry_name}/
+        puts "adding '#{entry_addr}\t#{entry_name}' to /etc/hosts"
+        hosts << "\n#{entry_addr}\t#{entry_name}\n" 
+        File.open(host_file, 'w') {|f| f.write(hosts) }
+      end
+    end      
+
+    def web_starting_port
+      mongrel_config['port'].to_i rescue 8000
+    end
+
+    def web_num_instances
+      mongrel_config['servers'].to_i rescue 6
+    end
+
+    def web_port_range
+      (web_starting_port..(web_starting_port + web_num_instances-1))
+    end
+
+    private
+
+    def mongrel_config
+      @mongrel_config ||= YAML::load_file(MONGREL_CONF_FILE)
+    end
+
+  end
+end

data/server/files/usr/local/ec2onrails/lib/s3_helper.rb

@@ -0,0 +1,126 @@
+#    This file is part of EC2 on Rails.
+#    http://rubyforge.org/projects/ec2onrails/
+#
+#    Copyright 2007 Paul Dowman, http://pauldowman.com/
+#
+#    EC2 on Rails is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    EC2 on Rails is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubygems'
+require 'aws/s3'
+require 'yaml'
+require 'erb'
+require 'fileutils'
+require "#{File.dirname(__FILE__)}/utils"
+
+module Ec2onrails
+  class S3Helper
+
+    DEFAULT_CONFIG_FILE = "/mnt/app/current/config/s3.yml"
+  
+    # make attributes available for specs
+    attr_accessor :bucket
+    attr_accessor :dir
+    attr_accessor :config_file
+    attr_accessor :rails_env
+    attr_accessor :aws_access_key
+    attr_accessor :aws_secret_access_key
+    attr_accessor :bucket
+
+    def initialize(bucket, dir, config_file = DEFAULT_CONFIG_FILE, rails_env = Utils.rails_env)
+      @dir = dir
+      @config_file = config_file
+      @rails_env = rails_env
+      load_s3_config
+      @bucket = bucket || "#{@bucket_base_name}-#{Ec2onrails::Utils.hostname}"
+      AWS::S3::Base.establish_connection!(:access_key_id => @aws_access_key, :secret_access_key => @aws_secret_access_key, :use_ssl => true)
+    end
+
+    def load_s3_config
+      if File.exists?(@config_file)
+        s3_config = YAML::load(ERB.new(File.read(@config_file)).result)
+    
+        # try to load the section for the current RAILS_ENV
+        section = s3_config[@rails_env]
+        if section.nil?
+          # fall back to keys at the root of the tree
+          section = s3_config
+        end
+    
+        @aws_access_key        = section['aws_access_key']
+        @aws_secret_access_key = section['aws_secret_access_key']
+        @bucket_base_name      = section['bucket_base_name']
+      else
+        if !File.exists?('/mnt/aws-config/config')
+          raise "Can't find either #{@config_file} or /mnt/aws-config/config"
+        end
+        @aws_access_key        = get_bash_config('AWS_ACCESS_KEY_ID')
+        @aws_secret_access_key = get_bash_config('AWS_SECRET_ACCESS_KEY')
+        @bucket_base_name      = get_bash_config('BUCKET_BASE_NAME')  
+      end
+    end
+
+    def create_bucket
+      retries = 0
+      begin
+        AWS::S3::Bucket.find(@bucket)
+      rescue AWS::S3::NoSuchBucket
+        AWS::S3::Bucket.create(@bucket)
+        sleep 1 # If we try to use the bucket too quickly sometimes it's not found
+        retry if (retries += 1) < 15
+      end
+    end
+
+    def store_file(file)
+      create_bucket
+      AWS::S3::S3Object.store(s3_key(file), open(file), @bucket)
+    end
+
+    def retrieve_file(file)
+      key = s3_key(file)
+      AWS::S3::S3Object.find(key, @bucket)
+      open(file, 'w') do |f|
+        AWS::S3::S3Object.stream(key, @bucket) do |chunk|
+          f.write chunk
+        end
+      end
+    end
+    
+    def list_keys(filename_prefix)
+      prefix = @dir ? "#{@dir}/#{filename_prefix}" : filename_prefix
+      AWS::S3::Bucket.objects(@bucket, :prefix => prefix).collect{|obj| obj.key}
+    end
+    
+    def retrieve_files(filename_prefix, local_dir)
+      list_keys(filename_prefix).each do |k|
+        file = "#{local_dir}/#{File.basename(k)}"
+        retrieve_file(file)
+      end      
+    end
+
+    def delete_files(filename_prefix)
+      list_keys(filename_prefix).each do |k|
+        AWS::S3::S3Object.delete(k, @bucket)
+      end
+    end
+  
+    def s3_key(file)
+      @dir ? "#{@dir}/#{File.basename(file)}" : File.basename(file)
+    end
+
+    # load an env value from the shared config file
+    def get_bash_config(name)
+      `bash -c 'source /mnt/aws-config/config; echo $#{name}'`.strip
+    end
+  end
+end

data/server/files/usr/local/ec2onrails/lib/utils.rb

@@ -0,0 +1,16 @@
+module Ec2onrails
+  module Utils
+    def self.run(command)
+      result = system command
+      raise("error: #{$?}") unless result
+    end
+  
+    def self.rails_env
+      `/usr/local/ec2onrails/bin/rails_env`.strip
+    end
+    
+    def self.hostname
+      `hostname -s`.strip
+    end
+  end
+end

data/server/files/usr/local/ec2onrails/lib/vendor/ini.rb

@@ -0,0 +1,268 @@
+# from ini gem, version 0.1.1
+# modified to allow keys with no value to be passed in (search for MODIFIED)
+#
+# This class represents the INI file and can be used to parse, modify,
+# and write INI files.
+#
+class Ini
+
+  # :stopdoc:
+  class Error < StandardError; end
+  # :startdoc:
+
+  #
+  # call-seq:
+  #    IniFile.load( filename )
+  #    IniFile.load( filename, options )
+  #
+  # Open the given _filename_ and load the contetns of the INI file.
+  # The following _options_ can be passed to this method:
+  #
+  #    :comment => ';'      The line comment character(s)
+  #    :parameter => '='    The parameter / value separator
+  #
+  def self.load( filename, opts = {} )
+    new(filename, opts)
+  end
+
+  #
+  # call-seq:
+  #    IniFile.new( filename )
+  #    IniFile.new( filename, options )
+  #
+  # Create a new INI file using the given _filename_. If _filename_
+  # exists and is a regular file, then its contents will be parsed.
+  # The following _options_ can be passed to this method:
+  #
+  #    :comment => ';'      The line comment character(s)
+  #    :parameter => '='    The parameter / value separator
+  #
+  def initialize( filename, opts = {} )
+    @fn = filename
+    @comment = opts[:comment] || ';'
+    @param = opts[:parameter] || '='
+    @ini = Hash.new {|h,k| h[k] = Hash.new}
+
+    @rgxp_comment = %r/\A\s*\z|\A\s*[#{@comment}]/
+    @rgxp_section = %r/\A\s*\[([^\]]+)\]/o
+    #MODIFIED: added #{@param}?... that question mark means that we will match rows
+    #          with just a key, but no value
+    @rgxp_param   = %r/\A([^#{@param}]+)#{@param}?(.*)\z/
+
+    parse
+  end
+
+  #
+  # call-seq:
+  #    write
+  #    write( filename )
+  #
+  # Write the INI file contents to the filesystem. The given _filename_
+  # will be used to write the file. If _filename_ is not given, then the
+  # named used when constructing this object will be used.
+  #
+  def write( filename = nil )
+    @fn = filename unless filename.nil?
+
+    ::File.open(@fn, 'w') do |f|
+      @ini.each do |section,hash|
+        f.puts "[#{section}]"
+        #MODIFY: do not print out the '=' if there is no value... PLUS remove spaces around the '='
+        hash.each {|param,val| f.puts val.nil? ? param : "#{param}#{@param}#{val}"}
+        f.puts
+      end
+    end
+    self
+  end
+  alias :save :write
+
+  #
+  # call-seq:
+  #    each {|section, parameter, value| block}
+  #
+  # Yield each _section_, _parameter_, _value_ in turn to the given
+  # _block_. The method returns immediately if no block is supplied.
+  #
+  def each
+    return unless block_given?
+    @ini.each do |section,hash|
+      hash.each do |param,val|
+        yield section, param, val
+      end
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #    each_section {|section| block}
+  #
+  # Yield each _section_ in turn to the given _block_. The method returns
+  # immediately if no block is supplied.
+  #
+  def each_section
+    return unless block_given?
+    @ini.each_key {|section| yield section}
+    self
+  end
+
+  #
+  # call-seq:
+  #    delete_section( section )
+  #
+  # Deletes the named _section_ from the INI file. Returns the
+  # parameter / value pairs if the section exists in the INI file. Otherwise,
+  # returns +nil+.
+  #
+  def delete_section( section )
+    @ini.delete section.to_s
+  end
+
+  #
+  # call-seq:
+  #    ini_file[section]
+  #
+  # Get the hash of parameter/value pairs for the given _section_. If the
+  # _section_ hash does not exist it will be created.
+  #
+  def []( section )
+    return nil if section.nil?
+    @ini[section.to_s]
+  end
+
+  #
+  # call-seq:
+  #    has_section?( section )
+  #
+  # Returns +true+ if the named _section_ exists in the INI file.
+  #
+  def has_section?( section )
+    @ini.has_key? section.to_s
+  end
+
+  #
+  # call-seq:
+  #    sections
+  #
+  # Returns an array of the section names.
+  #
+  def sections
+    @ini.keys
+  end
+
+  #
+  # call-seq:
+  #    freeze
+  #
+  # Freeze the state of the +IniFile+ object. Any attempts to change the
+  # object will raise an error.
+  #
+  def freeze
+    super
+    @ini.each_value {|h| h.freeze}
+    @ini.freeze
+    self
+  end
+
+  #
+  # call-seq:
+  #    taint
+  #
+  # Marks the INI file as tainted -- this will traverse each section marking
+  # each section as tainted as well.
+  #
+  def taint
+    super
+    @ini.each_value {|h| h.taint}
+    @ini.taint
+    self
+  end
+
+  #
+  # call-seq:
+  #    dup
+  #
+  # Produces a duplicate of this INI file. The duplicate is independent of the
+  # original -- i.e. the duplicate can be modified without changing the
+  # orgiinal. The tainted state of the original is copied to the duplicate.
+  #
+  def dup
+    other = super
+    other.instance_variable_set(:@ini, Hash.new {|h,k| h[k] = Hash.new})
+    @ini.each_pair {|s,h| other[s].merge! h}
+    other.taint if self.tainted?
+    other
+  end
+
+  #
+  # call-seq:
+  #    clone
+  #
+  # Produces a duplicate of this INI file. The duplicate is independent of the
+  # original -- i.e. the duplicate can be modified without changing the
+  # orgiinal. The tainted state and the frozen state of the original is copied
+  # to the duplicate.
+  #
+  def clone
+    other = dup
+    other.freeze if self.frozen?
+    other
+  end
+
+  #
+  # call-seq:
+  #    eql?( other )
+  #
+  # Returns +true+ if the _other_ object is equivalent to this INI file. For
+  # two INI files to be equivalent, they must have the same sections with  the
+  # same parameter / value pairs in each section.
+  #
+  def eql?( other )
+    return true if equal? other
+    return false unless other.instance_of? self.class
+    @ini == other.instance_variable_get(:@ini)
+  end
+  alias :== :eql?
+
+
+  private
+  #
+  # call-seq
+  #    parse
+  #
+  # Parse the ini file contents.
+  #
+  def parse
+    return unless ::Kernel.test ?f, @fn
+    section = nil
+
+    ::File.open(@fn, 'r') do |f|
+      while line = f.gets
+        line = line.chomp
+
+        case line
+        # ignore blank lines and comment lines
+        when @rgxp_comment: next
+
+        # this is a section declaration
+        when @rgxp_section: section = @ini[$1.strip]
+
+        # otherwise we have a parameter
+        when @rgxp_param
+          begin
+            #MODIFY: store no value as a nil instead of a blank
+            section[$1.strip] = $2.strip.size == 0 ? nil : $2.strip
+          rescue NoMethodError
+            raise Error, "parameter encountered before first section"
+          end
+
+        else
+          raise Error, "could not parse line '#{line}"
+        end
+      end  # while
+    end  # File.open
+  end
+
+end
+
+# EOF