rudy 0.2

data/lib/rudy/utils.rb

@@ -0,0 +1,65 @@
+
+require 'socket'
+require 'open-uri'
+require 'date'
+
+require 'socket'
+require 'timeout'
+
+module Rudy
+  
+  # A motley collection of methods that Rudy loves to call!
+  module Utils
+    extend self
+    include Socket::Constants
+    
+    # Return the external IP address (the one seen by the internet)
+    def external_ip_address
+      ip = nil
+      %w{solutious.com/ip myip.dk/ whatismyip.com }.each do |sponge| # w/ backup
+        break unless ip.nil?
+        ip = (open("http://#{sponge}") { |f| /([0-9]{1,3}\.){3}[0-9]{1,3}/.match(f.read) }).to_s rescue nil
+      end
+      ip += "/32" if ip
+      ip
+    end
+    
+    # Return the local IP address which receives external traffic
+    # from: http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+    # NOTE: This <em>does not</em> open a connection to the IP address. 
+    def internal_ip_address
+      # turn off reverse DNS resolution temporarily 
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true   
+      ip = UDPSocket.open {|s| s.connect('75.101.137.7', 1); s.addr.last } # Solutious IP
+      ip += "/24" if ip
+      ip
+    ensure  
+      Socket.do_not_reverse_lookup = orig
+    end
+    
+    # Generates a canonical tag name in the form:
+    #     rudy-2009-12-31-r1
+    # where r1 refers to the revision number that day
+    def generate_tag(revision=1)
+      n = DateTime.now
+      y = n.year.to_s.rjust(4, "20")
+      m = n.month.to_s.rjust(2, "0")
+      d = n.mday.to_s.rjust(2, "0")
+      "rudy-%4s-%2s-%2s-r%s" % [y, m, d, revision.to_s.rjust(2, "0")] 
+    end
+    
+    
+    def service_available?(host, port)
+      begin
+        status = Timeout::timeout(3) do
+          socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+          sockaddr = Socket.pack_sockaddr_in( port, host )
+          socket.connect( sockaddr )
+        end
+        true
+      rescue Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error => ex
+        false
+      end
+    end
+  end
+end

data/lib/storable.rb

@@ -0,0 +1,268 @@
+#--
+# TODO: Handle nested hashes and arrays. 
+# TODO: to_xml, see: http://codeforpeople.com/lib/ruby/xx/xx-2.0.0/README
+#++
+
+require 'yaml'
+require 'fileutils'
+
+
+# Storable makes data available in multiple formats and can
+# re-create objects from files. Fields are defined using the 
+# Storable.field method which tells Storable the order and 
+# name.
+class Storable
+  NICE_TIME_FORMAT  = "%Y-%m-%d@%H:%M:%S".freeze unless defined? NICE_TIME_FORMAT
+  SUPPORTED_FORMATS = %w{tsv csv yaml json}.freeze unless defined? SUPPORTED_FORMATS
+  
+  # This value will be used as a default unless provided on-the-fly.
+  # See SUPPORTED_FORMATS for available values.
+  attr_reader :format
+  
+  # See SUPPORTED_FORMATS for available values
+  def format=(v)
+    raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
+    @format = v
+  end
+  
+  def init
+    self.class.send(:class_variable_set, :@@field_names, []) unless class_variable_defined?(:@@field_names)
+    self.class.send(:class_variable_set, :@@field_types, []) unless class_variable_defined?(:@@field_types)
+  end
+  
+  # Accepts field definitions in the one of the follow formats:
+  #
+  #     field :product
+  #     field :product => Integer
+  #
+  # The order they're defined determines the order the will be output. The fields
+  # data is available by the standard accessors, class.product and class.product= etc...
+  # The value of the field will be cast to the type (if provided) when read from a file. 
+  # The value is not touched when the type is not provided. 
+  def self.field(args={})
+    # TODO: Examine casting from: http://codeforpeople.com/lib/ruby/fattr/fattr-1.0.3/
+    args = {args => nil} unless args.is_a? Hash
+
+    args.each_pair do |m,t|
+      
+      [[:@@field_names, m], [:@@field_types, t]].each do |tuple|
+        class_variable_set(tuple[0], []) unless class_variable_defined?(tuple[0])
+        class_variable_set(tuple[0], class_variable_get(tuple[0]) << tuple[1])
+      end
+      
+      next if method_defined?(m)
+      
+      define_method(m) do instance_variable_get("@#{m}") end
+      define_method("#{m}=") do |val| 
+        instance_variable_set("@#{m}",val)
+      end
+    end
+  end
+  
+  # Returns an array of field names defined by self.field
+  def self.field_names
+    class_variable_get(:@@field_names)
+  end
+  # Ditto.
+  def field_names
+    self.class.send(:class_variable_get, :@@field_names)
+  end
+  # Returns an array of field types defined by self.field. Fields that did 
+  # not receive a type are set to nil. 
+  def self.field_types
+    class_variable_get(:@@field_types)
+  end
+  # Ditto.
+  def field_types
+    self.class.send(:class_variable_get, :@@field_types)
+  end
+
+  # Dump the object data to the given format. 
+  def dump(format=nil, with_titles=true)
+    format ||= @format
+    raise "Format not defined (#{format})" unless SUPPORTED_FORMATS.member?(format)
+    send("to_#{format}", with_titles) 
+  end
+  
+  # Create a new instance of the object using data from file. 
+  def self.from_file(file_path=nil, format=nil)
+    raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
+    format = format || File.extname(file_path).tr('.', '')
+    me = send("from_#{format}", read_file_to_array(file_path))
+    me.format = format
+    me
+  end
+  # Write the object data to the given file. 
+  def to_file(file_path=nil, with_titles=true)
+    raise "Cannot store to nil path" if file_path.nil?
+    format = File.extname(file_path).tr('.', '')
+    format ||= @format
+    Storable.write_file(file_path, dump(format, with_titles))
+  end
+
+  # Create a new instance of the object from a hash.
+  def self.from_hash(from={})
+    me = self.new
+  
+    return me if !from || from.empty?
+    
+    fnames = field_names
+    fnames.each_with_index do |key,index|
+      
+      
+      
+      # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
+      
+      if field_types[index] == Time
+        value = Time.parse(from[key].to_s)
+      elsif field_types[index] == DateTime
+        value = DateTime.parse(from[key].to_s)
+      elsif field_types[index] == TrueClass
+        value = (from[key].to_s == "true")
+      elsif field_types[index] == Float
+        value = from[key].to_f
+      elsif field_types[index] == Integer
+        value = from[key].to_i
+      elsif field_types[index] == Array
+        (value ||= []) << from[key]
+      else
+        value = from[key] || from[key.to_s] # support for symbol keys and string keys
+        value = value.first if value.is_a?(Array) && value.size == 1 # I
+      end
+      
+      me.send("#{key}=", value) if self.method_defined?("#{key}=")  
+    end
+    
+    me
+  end
+  # Return the object data as a hash
+  # +with_titles+ is ignored. 
+  def to_hash(with_titles=true)
+    tmp = {}
+    field_names.each do |fname|
+      tmp[fname] = self.send(fname)
+    end
+    tmp
+  end
+  
+  # Create a new instance of the object from YAML. 
+  # +from+ a YAML string split into an array by line. 
+  def self.from_yaml(from=[])
+    # from is an array of strings
+    from_str = from.join('')
+    hash = YAML::load(from_str)
+    hash = from_hash(hash) if hash.is_a? Hash 
+    hash
+  end
+  def to_yaml(with_titles=true)
+    to_hash.to_yaml
+  end
+  
+  # Create a new instance of the object from a JSON string. 
+  # +from+ a JSON string split into an array by line.
+  def self.from_json(from=[])
+    require 'json'
+    # from is an array of strings
+    from_str = from.join('')
+    tmp = JSON::load(from_str)
+    hash_sym = tmp.keys.inject({}) do |hash, key|
+       hash[key.to_sym] = tmp[key]
+       hash
+    end
+    hash_sym = from_hash(hash_sym) if hash_sym.is_a? Hash  
+    hash_sym
+  end
+  def to_json(with_titles=true)
+    require 'json'
+    to_hash.to_json
+  end
+  
+  # Return the object data as a delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  # +delim+ is the field delimiter.
+  def to_delimited(with_titles=false, delim=',')
+    values = []
+    field_names.each do |fname|
+      values << self.send(fname.to_s)   # TODO: escape values
+    end
+    output = values.join(delim)
+    output = field_names.join(delim) << $/ << output if with_titles
+    output
+  end
+  # Return the object data as a tab delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  def to_tsv(with_titles=false)
+    to_delimited(with_titles, "\t")
+  end
+  # Return the object data as a comma delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  def to_csv(with_titles=false)
+    to_delimited(with_titles, ',')
+  end
+  # Create a new instance from tab-delimited data.  
+  # +from+ a JSON string split into an array by line.
+  def self.from_tsv(from=[])
+    self.from_delimited(from, "\t")
+  end
+  # Create a new instance of the object from comma-delimited data.
+  # +from+ a JSON string split into an array by line.
+  def self.from_csv(from=[])
+    self.from_delimited(from, ',')
+  end
+  
+  # Create a new instance of the object from a delimited string.
+  # +from+ a JSON string split into an array by line.
+  # +delim+ is the field delimiter.
+  def self.from_delimited(from=[],delim=',')
+    return if from.empty?
+    # We grab an instance of the class so we can 
+    hash = {}
+    
+    fnames = values = []
+    if (from.size > 1 && !from[1].empty?)
+      fnames = from[0].chomp.split(delim)
+      values = from[1].chomp.split(delim)
+    else
+      fnames = self.field_names
+      values = from[0].chomp.split(delim)
+    end
+    
+    fnames.each_with_index do |key,index|
+      next unless values[index]
+      hash[key.to_sym] = values[index]
+    end
+    hash = from_hash(hash) if hash.is_a? Hash 
+    hash
+  end
+
+  def self.read_file_to_array(path)
+    contents = []
+    return contents unless File.exists?(path)
+    
+    open(path, 'r') do |l|
+      contents = l.readlines
+    end
+
+    contents
+  end
+  
+  def self.write_file(path, content, flush=true)
+    write_or_append_file('w', path, content, flush)
+  end
+  
+  def self.append_file(path, content, flush=true)
+    write_or_append_file('a', path, content, flush)
+  end
+  
+  def self.write_or_append_file(write_or_append, path, content = '', flush = true)
+    #STDERR.puts "Writing to #{ path }..." 
+    create_dir(File.dirname(path))
+    
+    open(path, write_or_append) do |f| 
+      f.puts content
+      f.flush if flush;
+    end
+    File.chmod(0600, path)
+  end
+end
+

data/rudy.gemspec

@@ -0,0 +1,52 @@
+@spec = Gem::Specification.new do |s|
+	s.name = "rudy"
+	s.version = "0.2"
+	s.summary = "Rudy is a handy staging and deployment tool for Amazon EC2."
+	s.description = "Rudy is a handy staging and deployment tool for Amazon EC2."
+	s.author = "Delano Mandelbaum"
+	s.email = "delano@solutious.com"
+	s.homepage = "http://github.com/solutious/rudy"
+ 
+  # = MANIFEST =
+  # find {bin,lib,support,tryouts} -type f | grep -v git
+  s.files = %w(
+  CHANGES.txt
+  LICENSE.txt
+  README.rdoc
+  Rakefile
+  bin/rudy
+  lib/drydock.rb
+  lib/rudy.rb
+  lib/rudy/aws.rb
+  lib/rudy/aws/ec2.rb
+  lib/rudy/aws/s3.rb
+  lib/rudy/aws/simpledb.rb
+  lib/rudy/command/addresses.rb
+  lib/rudy/command/base.rb
+  lib/rudy/command/commit.rb
+  lib/rudy/command/disks.rb
+  lib/rudy/command/environment.rb
+  lib/rudy/command/groups.rb
+  lib/rudy/command/images.rb
+  lib/rudy/command/instances.rb
+  lib/rudy/command/metadata.rb
+  lib/rudy/command/release.rb
+  lib/rudy/command/volumes.rb
+  lib/rudy/metadata/disk.rb
+  lib/rudy/metadata/environment.rb
+  lib/rudy/scm/svn.rb
+  lib/rudy/utils.rb
+  lib/storable.rb
+  rudy.gemspec
+  support/rudy-ec2-startup
+  )
+  s.executables = %w[rudy]
+  
+  s.extra_rdoc_files = %w[README.rdoc LICENSE.txt]
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rudy: Your friend in staging and deploying with EC2", "--main", "README.rdoc"]
+  s.require_paths = %w[lib]
+  s.rubygems_version = '1.1.1'
+  
+  s.rubyforge_project = 'rudy'
+end

data/support/rudy-ec2-startup

@@ -0,0 +1,166 @@
+#!/usr/bin/ruby
+
+# what: Rudy EC2 startup script
+#  who: delano@solutious.com
+# when: 2009-02-20 (rev: 3)
+
+# NOTE: This is a prototype version of this script. A cleaner version 
+# with better documentation is forthcoming.
+
+# Runs when an ec2 instance startups up.
+# Grabs configuration from the run time user data and stores it locally.
+# Expects message data in the yaml format:
+#
+# :dbmaster: IP ADDRESS or LOCAL HOSTNAME (default: localhost)
+# :role: app, db, etc... (default: app)
+# :env: stage, prod (default: stage)
+# :access_key: amazon access key
+# :secret_key: amazon secret key
+
+# Put this in /etc/init.d. Then:
+#   * chmod 755 rudy-ec2-startup
+#   * cd /etc/rc3.d
+#   * ln -s ../init.d/rudy-ec2-startup S17rudy
+#   * cd /etc/rc4.d                    
+#   * ln -s ../init.d/rudy-ec2-startup S17rudy
+#   * cd /etc/rc5.d                    
+#   * ln -s ../init.d/rudy-ec2-startup S17rudy
+
+require 'yaml'
+require 'resolv'
+
+LOGFILE = '/var/log/rudy-ec2-startup'
+USERDATA = 'http://169.254.169.254/2008-02-01/user-data'
+METADATA = 'http://169.254.169.254/2008-02-01/meta-data'
+METADATAPARAMS = ['instance-id', 'instance-type']
+
+
+def get_metadata
+  metadata = {}
+  
+  begin
+    METADATAPARAMS.each do |param|
+      log "  ---> #{param}"
+      metadata[param.to_s] = run("curl -s #{METADATA}/#{param}")
+    end
+  rescue => ex
+    log("Problem getting metadata: #{ex.message}")
+  end
+  metadata
+end
+
+def run(command, input='')
+  IO.popen(command, 'r+') do |io|
+    #io.puts input
+    #io.close_write
+    return io.read
+  end
+end  
+
+def get_formatted_time
+  t = Time.now
+  t_out = t.strftime("%H:%M:%S%p (%m/%d/%Y)")
+end
+
+def write_to_file (filename, s, type='a')
+  f = File.open(filename,type)
+  f.puts s
+  f.close
+end
+
+def read_file(path)
+  read_file_to_array(path).join('')
+end
+
+def read_file_to_array(path)
+  contents = []
+  return contents unless File.exists?(path)
+  open(path, 'r') do |l|
+    contents = l.readlines
+  end
+  contents
+end
+
+def log(s)
+  msg = "#{get_formatted_time}: #{s}"
+  write_to_file(LOGFILE, msg)
+  puts msg
+end
+
+begin
+  File.unlink(LOGFILE) if File.exists?(LOGFILE)
+  log "Deleted previous logfile (#{LOGFILE})"
+  log "Grabing configuration..."
+  config_yaml = run("curl -s #{USERDATA}")
+  
+  log "Grabing meta-data..."
+  metadata = get_metadata
+  
+  raise "Ooooooops, no configuration" if !config_yaml || config_yaml.empty?
+  
+  config = YAML::load(config_yaml)
+  
+  if config && config[:role]
+    myrole = config[:role].downcase
+    
+  else
+    myrole = "app"
+  end
+  
+  log "My role is: #{myrole}"
+  
+  env = config && config[:env] ? config[:env] : "stage"
+  
+  unless read_file('/etc/hosts') =~ /dbmaster/
+    if config && config[:dbmaster]
+      log "Updating dbmaster in /etc/hosts..."
+    
+      case config[:dbmaster]
+      when /^\d.+/
+        ip_address = config[:dbmaster]
+      else    
+        ip_address = Resolv.getaddress(config[:dbmaster])
+      end
+    
+      log "The IP address for my dbmaster is: #{ip_address}"
+      write_to_file("/etc/hosts", "\n#{ip_address}\tdbmaster\n")
+      
+    else
+      write_to_file("/etc/hosts", "\n127.0.0.1\tdbmaster\n")
+    end
+  end
+  
+
+  hostname = ""
+  myid = "default-"
+  if metadata['instance-id']
+    myid = metadata['instance-id'][2..metadata['instance-id'].length]
+    log "My ID: #{myid}"
+    write_to_file("/etc/instance-id", myid, "w")   
+  end
+  
+  mytype = "unknown"
+  if metadata['instance-type']
+    mytype = metadata['instance-type']
+    log "My instance type: #{metadata['instance-type']}"
+    write_to_file("/etc/instance-type", metadata['instance-type'], "w")
+  end
+  
+  
+  hostname = "#{env}-#{myrole}-#{mytype.gsub('.', '')}-#{myid}" 
+  log "Setting hostname to #{hostname}"
+  `hostname #{hostname}`
+  
+  unless read_file('/etc/hosts') =~ /#{hostname}/
+    log "Adding an entry to /etc/hosts for: #{hostname}"
+    write_to_file("/etc/hosts", "\n127.0.0.1\t#{hostname}")
+  end
+  
+  log "Done!"
+  
+rescue => ex
+  log ex.message
+end
+  
+
+