awsborn 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Vrensk
+
+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/README.mdown

@@ -0,0 +1,204 @@
+# awsborn
+
+This Gem lets you define and launch a server cluster on Amazon EC2.
+The `launch` operation is idempotent, i.e., it only launches instances
+that are not running.
+
+## Installation
+
+    gem install awsborn
+
+## Synopsis
+
+    #! /usr/bin/env ruby
+
+    require 'rubygems'
+    require 'awsborn'
+
+    # If not set, will be picked up from ENV['AMAZON_ACCESS_KEY_ID']
+    # and ENV['AMAZON_SECRET_ACCESS_KEY'].
+    Awsborn.access_key_id = 'AAAAAAAAAAAA'
+    Awsborn.secret_access_key = 'KKKKKKKKKKKK'
+
+    # Logs to `awsborn.log` in current dir with level INFO by default.
+    # To suppress logging, do `Awsborn.logger = Logger.new('/dev/null')`
+    Awsborn.logger.level = Logger::DEBUG
+
+    class LogServer < Awsborn::Server
+      instance_type    :m1_small
+      image_id         'ami-2fc2e95b', :sudo_user => 'ubuntu'
+      security_group   'Basic web'
+      keys             'keys/*.pub'
+      bootstrap_script 'chef-bootstrap.sh'
+    end
+
+    log_servers = LogServer.cluster do
+      domain 'releware.net'
+      server :log_a, :zone => :eu_west_1a, :disk => {:sdf => "vol-a857b8c1"}, :ip => 'log-a'
+      server :log_b, :zone => :eu_west_1b, :disk => {:sdf => "vol-aa57b8c3"}, :ip => 'log-b'
+    end
+
+    log_servers.launch
+
+    log_servers.each do |server|
+      system "rake cook server=#{server.host_name}"
+    end
+
+## How it works
+
+It's really simple:
+
+1. Define a server type (`LogServer` in the example above).
+2. Define a cluster of server instances.
+3. Launch the cluster.
+
+See *Launching a cluster* below for details.
+
+### Defining a server type
+
+Server types can be named anything but must inherit from `Awsborn::Server`.
+Servers take five different directives:
+
+* `instance_type` -- a symbol.  One of `:m1_small`, `:m1_large`, `:m1_xlarge`,
+  `:m2_2xlarge`, `:m2_4xlarge`, `:c1_medium`, and `:c1_xlarge`.
+* `image_id` -- a valid EC2 AMI.  Specify `:sudo_user` as an option if the AMI
+  does not allow you to log in as root.
+* `security_group` -- a security group that you own.
+* `keys` -- one or more globs to public ssh keys.  When the servers are running,
+  `root` will be able to log in using any one of these keys.
+* `bootstrap_script` -- path to a script which will be run on each instance as
+  soon as it is started.  Use it to bootstrap `chef` and let `chef` take it from
+  there.  A sample bootstrap script is included towards the end of this document.
+
+A server cannot be started without `instance_type`, `image_id` and `security_group`.
+The don't have to be defined for the server type though, but can
+equally well be added as options to the specific servers.
+
+### Defining a cluster
+
+The `cluster` method accepts two commands, `domain` and `server`.  `domain` is
+optional and is just a way to avoid repetition in the `server` commands.  `server`
+takes a name (which can be used as a key in the cluster, e.g. `log_servers[:log_a]`)
+and a hash:
+
+Mandatory keys:
+
+* `:zone` -- the availability zone for the server.  One of `:us_east_1a`, `:us_east_1b`,
+  `:us_east_1c`, `:us_west_1a`, `:us_west_1b`, `:eu_west_1a`, `:eu_west_1b`.
+* `:disk` -- a hash of `device => volume-id`.  Awsborn uses the disks to tell if a server
+  is running or not (see *Launching a cluster*).
+* `:ip` -- a domain name which translates to an elastic ip.  If the domain name does not
+  contain a full stop (dot) and `domain` has been specified above, the domain is added.
+
+Keys that override server type settings:
+
+* `:instance_type`
+* `:sudo_user`
+* `:security_group`
+* `:keys`
+* `:bootstrap_script`
+
+### Launching a cluster
+
+The `launch` method on the cluster checks to see if each server is running by checking
+if *one of the server's disks is attached to an EC2 instance*, i.e., the server is
+defined by its content, not by its AMI or ip address.
+
+Servers that not running are started by calling the `start` method on the server,
+which does the following:
+
+    def start (key_pair)
+      launch_instance(key_pair)
+
+      update_known_hosts
+      install_ssh_keys(key_pair) if keys
+
+      if elastic_ip
+        associate_address
+        update_known_hosts
+      end
+
+      bootstrap if bootstrap_script
+      attach_volumes
+    end
+
+The `key_pair` is a temporary key pair that is used only for launching this cluster.
+In case of a failed launch, the private key is available as `/tmp/temp_key_*`.
+
+## A bootstrapping script
+
+This is what we use with the AMI above:
+
+    #!/bin/bash
+
+    echo '------------------'
+    echo 'Bootstrapping Chef'
+    echo
+
+    aptitude -y update
+    aptitude -y install gcc g++ curl build-essential \
+      libxml-ruby libxml2-dev \
+      ruby irb ri rdoc ruby1.8-dev libzlib-ruby libyaml-ruby libreadline-ruby \
+      libruby libruby-extras libopenssl-ruby \
+      libdbm-ruby libdbi-ruby libdbd-sqlite3-ruby \
+      sqlite3 libsqlite3-dev libsqlite3-ruby
+
+    curl -L 'http://rubyforge.org/frs/download.php/69365/rubygems-1.3.6.tgz' | tar zxf -
+    cd rubygems* && ruby setup.rb --no-ri --no-rdoc
+
+    ln -sfv /usr/bin/gem1.8 /usr/bin/gem
+
+    gem install chef ohai --no-ri --no-rdoc --source http://gems.opscode.com --source http://gems.rubyforge.org
+
+    echo
+    echo 'Bootstrapping Chef - done'
+    echo '-------------------------'
+
+## Bugs and surprising features
+
+No bugs are known at this time.
+
+If a server is defined with two disks and the disks are attached to different
+EC2 instances, the server will still be considered running.  If one disk is
+attached and the other isn't, one of these things will happen:
+
+* The server is considered to be running, *or*
+* The server is considered down and an attempt to start it will likely fail since
+  one disk is already attached to another instance.
+
+### Untested features
+
+* Launching without ssh keys.  (I suppose certain AMIs would support that.)
+* Running without elastic ip.
+
+## To do / Could do
+
+* Tests.
+* Add cloud watch
+* Dynamic discovery of instance types and availability zones.
+* Hack RightAws to verify certificates.
+* Elastic Load Balancing.
+* Launch servers in parallel.
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* At the moment, the gem does not have any tests.  I intend to fix that,
+  and I won't accept patches without tests.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## History
+
+This gem is inspired by [Awsymandias](http://github.com/bguthrie/awsymandias)
+which was sort of what I needed but was too complicated to fix, partly because
+the documentation was out of date.  Big thanks for the inspiration and random
+code snippets.
+
+## Copyright
+
+Copyright (c) 2010 ICE House & David Vrensk. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "awsborn"
+    gem.summary = %Q{Awsborn lets you define and launch a server cluster on Amazon EC2.}
+    gem.description = %Q{Awsborn defines servers as instances with a certain disk volume, which makes it easy to restart missing servers.}
+    gem.email = "david@icehouse.se"
+    gem.homepage = "http://github.com/icehouse/awsborn"
+    gem.authors = ["David Vrensk"]
+    gem.add_dependency "right_aws", ">= 1.10.0"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "webmock", ">= 0.9.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "awsborn #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/awsborn/awsborn.rb

@@ -0,0 +1,58 @@
+module Awsborn
+  class SecurityError < StandardError ; end
+
+  class << self
+    attr_writer :access_key_id, :secret_access_key, :logger
+    attr_accessor :verbose
+  
+    Awsborn.verbose = true
+  
+    def access_key_id
+      @access_key_id ||= ENV['AMAZON_ACCESS_KEY_ID'] 
+    end
+    
+    def secret_access_key
+      @secret_access_key ||= ENV['AMAZON_SECRET_ACCESS_KEY']
+    end
+  
+    def logger
+      unless defined? @logger
+        dir = [File.dirname(File.expand_path($0)), '/tmp'].find { |d| File.writable?(d) }
+        if dir
+          file = File.open(File.join(dir, 'awsborn.log'), 'a')
+          file.sync = true
+        end
+        @logger = Logger.new(file || $stdout)
+        @logger.level = Logger::INFO
+      end
+      @logger
+    end
+  
+    # @throws Interrupt
+    def wait_for (message, sleep_seconds = 5, max_wait_seconds = nil)
+      stdout_sync = $stdout.sync
+      $stdout.sync = true
+
+      start_at = Time.now
+      print "Waiting for #{message}.." if Awsborn.verbose
+      result = yield
+      while ! result
+        if max_wait_seconds && Time.now > start_at + max_wait_seconds
+          raise Interrupt, "Timed out after #{Time.now - start_at} seconds."
+        end
+        print "." if Awsborn.verbose
+        sleep sleep_seconds
+        result = yield
+      end
+      verbose_output "OK!"
+      result
+    ensure
+      $stdout.sync = stdout_sync
+    end
+  
+    def verbose_output(message)
+      puts message if Awsborn.verbose
+    end
+    
+  end
+end

data/lib/awsborn/ec2.rb

@@ -0,0 +1,87 @@
+module Awsborn
+  class Ec2
+
+    attr_accessor :instance_id
+
+    def connection
+      unless @connection
+        env_ec2_url = ENV['EC2_URL']
+        begin
+          ENV['EC2_URL'] = @endpoint
+          @connection = ::RightAws::Ec2.new(Awsborn.access_key_id,
+                                            Awsborn.secret_access_key,
+                                            :logger => Awsborn.logger)
+        ensure
+          ENV['EC2_URL'] = env_ec2_url
+        end
+      end
+      @connection
+    end      
+    
+    def initialize (zone)
+      @endpoint = case zone
+      when :eu_west_1a, :eu_west_1b
+        'https://eu-west-1.ec2.amazonaws.com/'
+      when :us_east_1a, :us_east_1b
+        'https://us-east-1.ec2.amazonaws.com'
+      else
+        'https://ec2.amazonaws.com'
+      end
+    end
+
+    KeyPair = Struct.new :name, :path
+    
+    def generate_key_pair
+      time = Time.now
+      key_name = "temp_key_#{time.to_i}_#{time.usec}"
+      key_data = connection.create_key_pair(key_name)
+      file_path = File.join(ENV['TMP_DIR'] || '/tmp', "#{key_name}.pem")
+      File.open file_path, "w", 0600 do |f|
+        f.write key_data[:aws_material]
+      end
+      KeyPair.new key_name, file_path
+    end
+
+    def delete_key_pair (key_pair)
+      connection.delete_key_pair(key_pair.name)
+    end
+    
+    def volume_has_instance? (volume_id)
+      response = connection.describe_volumes(volume_id).first
+      if response[:aws_status] == 'in-use'
+        self.instance_id = response[:aws_instance_id]
+        true
+      else
+        false
+      end
+    end
+    
+    IP4_REGEXP = /^(\d{1,3}\.){3}\d{1,3}$/
+
+    def associate_address (address)
+      unless address.match(IP4_REGEXP)
+        address = Resolv.getaddress address
+      end
+      connection.associate_address(instance_id, address)
+    end
+
+    def describe_instance
+      connection.describe_instances(instance_id).first
+    end
+
+    def launch_instance (*args)
+      response = connection.launch_instances(*args).first
+      self.instance_id = response[:aws_instance_id]
+      response
+    end
+    
+    def get_console_output
+      output = connection.get_console_output(instance_id)
+      output[:aws_output]
+    end
+    
+    def attach_volume (volume, device)
+      connection.attach_volume(volume, instance_id, device)
+    end
+  end
+end

data/lib/awsborn/extensions/proc.rb

@@ -0,0 +1,13 @@
+# Copied from ActiveSupport and modified
+class Proc #:nodoc:
+  def bind (object, basename = nil)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__#{basename || 'bind'}_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/lib/awsborn/known_hosts_updater.rb

@@ -0,0 +1,117 @@
+module Awsborn
+  class KnownHostsUpdater
+
+    class << self
+      attr_accessor :logger
+      def update_for_server (server)
+        known_hosts = new(server.ec2, server.host_name)
+        known_hosts.update
+      end
+
+      def logger
+        @logger ||= Awsborn.logger
+      end
+    end
+
+    attr_accessor :ec2, :host_name, :host_ip, :console_fingerprint, :fingerprint_file, :logger
+
+    def initialize (ec2, host_name)
+      @host_name = host_name
+      @ec2 = ec2
+    end
+
+    def update
+      tries = 0
+      begin
+        tries += 1
+        try_update
+      rescue SecurityError => e
+        if tries < 5
+          logger.debug e.message
+          logger.debug "Sleeping, try #{tries}"
+          sleep([2**tries, 15].min)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+    
+    def try_update
+      get_console_fingerprint
+      clean_out_known_hosts
+      scan_hosts
+      compare_fingerprints!
+      save_fingerprints
+    end
+
+    def get_console_fingerprint
+      # ec2: -----BEGIN SSH HOST KEY FINGERPRINTS-----
+      # ec2: 2048 7a:e9:eb:41:b7:45:b1:07:30:ad:13:c5:a9:2a:a1:e5 /etc/ssh/ssh_host_rsa_key.pub (RSA)
+      regexp = %r{BEGIN SSH HOST KEY FINGERPRINTS.*((?:[0-9a-f]{2}:){15}[0-9a-f]{2}) /etc/ssh/ssh_host_rsa_key.pub }m
+      @console_fingerprint = Awsborn.wait_for "console output", 15, 420 do
+        console = ec2.get_console_output
+        if console.any?
+          fingerprint = console[regexp, 1]
+          if ! fingerprint
+            logger.error "*** SSH RSA fingerprint not found ***"
+            logger.error lines
+            logger.error "*** SSH RSA fingerprint not found ***"
+          end
+        end
+        fingerprint
+      end
+    end
+
+    def clean_out_known_hosts
+      remove_from_known_hosts host_name
+      remove_from_known_hosts host_ip
+    end
+    
+    def remove_from_known_hosts (host)
+      system "ssh-keygen -R #{host} > /dev/null 2>&1"
+    end
+
+    def scan_hosts
+      self.fingerprint_file = create_tempfile
+      system "ssh-keyscan -t rsa #{host_name} #{host_ip} > #{fingerprint_file} 2>/dev/null"
+    end
+
+    def compare_fingerprints!
+      name_fingerprint, ip_fingerprint = fingerprints_from_file
+
+      if name_fingerprint.nil? || ip_fingerprint.nil?
+        raise SecurityError, "name_fingerprint = #{name_fingerprint.inspect}, ip_fingerprint = #{ip_fingerprint.inspect}"
+      elsif name_fingerprint.split[1] != ip_fingerprint.split[1]
+        raise SecurityError, "Fingerprints do not match:\n#{name_fingerprint} (#{host_name})\n#{ip_fingerprint} (#{host_ip})!"
+      elsif name_fingerprint.split[1] != console_fingerprint
+        raise SecurityError, "Fingerprints do not match:\n#{name_fingerprint} (#{host_name})\n#{console_fingerprint} (EC2 Console)!"
+      end
+    end
+    
+    def fingerprints_from_file
+      `ssh-keygen -l -f #{fingerprint_file}`.split("\n")
+    end
+
+    def save_fingerprints
+      system "cat #{fingerprint_file} >> #{ENV['HOME']}/.ssh/known_hosts"
+    end
+    
+    def create_tempfile
+      tmp = Tempfile.new "awsborn"
+      tmp.close
+      def tmp.to_s
+        path
+      end
+      tmp
+    end
+    
+    def logger
+      @logger ||= self.class.logger
+    end
+
+    def host_ip
+      @host_ip ||= Resolv.getaddress host_name
+    end
+  end
+end

data/lib/awsborn/server.rb

@@ -0,0 +1,207 @@
+module Awsborn
+  class Server
+    
+    def initialize (name, options = {})
+      @name = name
+      @options = options.dup
+      self.host_name = elastic_ip
+    end
+    
+    class << self
+      attr_accessor :logger
+      def image_id (*args)
+        unless args.empty?
+          @image_id = args.first
+          @sudo_user = args.last[:sudo_user] if args.last.is_a?(Hash)
+        end
+        @image_id
+      end
+      def instance_type (*args)
+        @instance_type = args.first unless args.empty?
+        @instance_type
+      end
+      def security_group (*args)
+        @security_group = args.first unless args.empty?
+        @security_group
+      end
+      def keys (*args)
+        @keys = args unless args.empty?
+        @keys
+      end
+      def sudo_user (*args)
+        @sudo_user = args.first unless args.empty?
+        @sudo_user
+      end
+      def bootstrap_script (*args)
+        @bootstrap_script = args.first unless args.empty?
+        @bootstrap_script
+      end
+      
+      def cluster (&block)
+        ServerCluster.build self, &block
+      end
+      def logger
+        @logger ||= Awsborn.logger
+      end
+    end
+
+    def one_of_my_disks_is_attached_to_a_running_instance?
+      vol_id = disk.values.first
+      ec2.volume_has_instance?(vol_id)
+    end
+    alias :running? :one_of_my_disks_is_attached_to_a_running_instance?
+
+    def start (key_pair)
+      launch_instance(key_pair)
+
+      update_known_hosts
+      install_ssh_keys(key_pair) if keys
+
+      if elastic_ip
+        associate_address
+        update_known_hosts
+      end
+
+      bootstrap if bootstrap_script
+      attach_volumes
+    end
+
+    def launch_instance (key_pair)
+      @launch_response = ec2.launch_instance(image_id,
+        :instance_type => constant(instance_type),
+        :availability_zone => constant(zone),
+        :key_name => key_pair.name,
+        :group_ids => security_group
+      )
+      logger.debug @launch_response
+
+      Awsborn.wait_for("instance #{instance_id} (#{name}) to start", 10) { instance_running? }
+      self.host_name = aws_dns_name
+    end
+
+    def update_known_hosts
+      KnownHostsUpdater.update_for_server self
+    end
+    
+    def install_ssh_keys (temp_key_pair)
+      cmd = "ssh -i #{temp_key_pair.path} #{sudo_user || 'root'}@#{aws_dns_name} 'cat > .ssh/authorized_keys'"
+      logger.debug cmd
+      IO.popen(cmd, "w") do |pipe|
+        pipe.puts key_data
+      end
+      if sudo_user
+        system("ssh #{sudo_user}@#{aws_dns_name} 'sudo cp .ssh/authorized_keys /root/.ssh/authorized_keys'")
+      end
+    end
+
+    def key_data
+      Dir[*keys].inject([]) do |memo, file_name|
+        memo + File.readlines(file_name).map { |line| line.chomp }
+      end.join("\n")
+    end
+
+    def path_relative_to_script (path)
+      File.join(File.dirname(File.expand_path($0)), path)
+    end
+    
+    def associate_address
+      ec2.associate_address(elastic_ip)
+      self.host_name = elastic_ip
+    end
+
+    def bootstrap
+      script = path_relative_to_script(bootstrap_script)
+      basename = File.basename(script)
+      system "scp #{script} root@#{elastic_ip}:/tmp"
+      system "ssh root@#{elastic_ip} 'cd /tmp && chmod 700 #{basename} && ./#{basename}'"
+    end
+    
+    def attach_volumes
+      disk.each_pair do |device, volume|
+        device = "/dev/#{device}" if device.is_a?(Symbol) || ! device.match('/')
+        res = ec2.attach_volume(volume, device)
+      end
+    end
+
+    def ec2
+      @ec2 ||= Ec2.new(zone)
+    end
+    
+    begin :accessors
+      attr_accessor :name, :host_name, :logger
+      def zone
+        @options[:zone]
+      end
+      def disk
+        @options[:disk]
+      end
+      def image_id
+        self.class.image_id
+      end
+      def instance_type
+        @options[:instance_type] || self.class.instance_type
+      end
+      def security_group
+        @options[:security_group] || self.class.security_group
+      end
+      def sudo_user
+        @options[:sudo_user] || self.class.sudo_user
+      end
+      def bootstrap_script
+        @options[:bootstrap_script] || self.class.bootstrap_script
+      end
+      def keys
+        @options[:keys] || self.class.keys
+      end
+      def elastic_ip
+        @options[:ip]
+      end
+      def instance_id
+        ec2.instance_id
+      end
+      def aws_dns_name
+        describe_instance[:dns_name]
+      end
+      def launch_time
+        xml_time = describe_instance[:aws_launch_time]
+        logger.debug xml_time
+        Time.xmlschema(xml_time)
+      end
+      def instance_running?
+        describe_instance![:aws_state] == 'running'
+      end
+      def describe_instance!
+        @describe_instance = nil
+        logger.debug describe_instance
+        describe_instance
+      end
+      def describe_instance
+        @describe_instance ||= ec2.describe_instance
+      end
+    end
+    
+    def constant (symbol)
+      {
+        :us_east_1a => "us-east-1a",
+        :us_east_1b => "us-east-1b",
+        :us_east_1c => "us-east-1c",
+        :us_west_1a => "us-west-1a",
+        :us_west_1b => "us-west-1b",
+        :eu_west_1a => "eu-west-1a",
+        :eu_west_1b => "eu-west-1b",
+        :m1_small   => "m1.small",
+        :m1_large   => "m1.large" ,
+        :m1_xlarge  => "m1.xlarge",
+        :m2_2xlarge => "m2.2xlarge",
+        :m2_4xlarge => "m2.4xlarge",
+        :c1_medium  => "c1.medium",
+        :c1_xlarge  => "c1.xlarge"
+      }[symbol]
+    end
+
+    def logger
+      @logger ||= self.class.logger
+    end
+    
+  end
+end

data/lib/awsborn/server_cluster.rb

@@ -0,0 +1,69 @@
+module Awsborn
+  class ServerCluster
+    def self.build (klass, &block)
+      cluster = new(klass)
+      block.bind(cluster, 'cluster').call
+      cluster
+    end
+
+    def initialize (klass)
+      @klass = klass
+      @instances = []
+    end
+    
+    def domain (*args)
+      @domain = args.first unless args.empty?
+      @domain
+    end
+    
+    def server (name, options = {})
+      options = add_domain_to_ip(options)
+      instance = @klass.new name, options
+      @instances << instance
+    end
+
+    def launch
+      start_missing_instances
+    end
+
+    def start_missing_instances
+      to_start = find_missing_instances
+      return if to_start.empty?
+      generate_key_pair(to_start)
+      to_start.each { |e| e.start(@key_pair) }
+      delete_key_pair(to_start)
+    end
+
+    def find_missing_instances
+      @instances.reject { |e| e.running? }
+    end
+
+    def generate_key_pair (instances)
+      @key_pair = instances.first.ec2.generate_key_pair
+    end
+
+    def delete_key_pair (instances)
+      instances.first.ec2.delete_key_pair(@key_pair)
+    end
+    
+    def each (&block)
+      @instances.each &block
+    end
+
+    def [] (name)
+      @instances.detect { |i| i.name == name }
+    end
+    
+    protected
+    
+    def add_domain_to_ip (hash)
+      if @domain && hash.has_key?(:ip) && ! hash[:ip].include?('.')
+        ip = [hash[:ip], @domain].join('.')
+        hash.merge(:ip => ip)
+      else
+        hash
+      end
+    end
+    
+  end
+end

data/lib/awsborn.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+require 'resolv'
+require 'tempfile'
+
+require 'rubygems'
+require 'right_aws'
+
+# %w[
+#   awsborn
+#   server
+#   server_cluster
+#   extensions/proc
+#   ].each { |e| require File.dirname(__FILE__) + "/awsborn/#{e}" }
+
+require 'pp'
+
+Dir[File.join(File.dirname(__FILE__), 'awsborn/**/*.rb')].sort.each { |lib| require lib }

data/spec/awsborn_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Awsborn" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class SampleServer < Awsborn::Server
+  instance_type :m1_small
+  image_id 'ami-2fc2e95b'
+  keys :all
+end
+
+describe Awsborn::Server do
+  before(:each) do
+    @server = SampleServer.new :sample, :zone => :eu_west_1a, :disk => {:sdf => "vol-aaaaaaaa"}
+  end
+  context "first of all" do
+    it "should have a connection to the EU service point"
+    
+  end
+  
+  context "#launch when not started" do
+    before(:each) do
+      @server.stub(:running?).and_return(false)
+    end
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'awsborn'
+require 'spec'
+require 'spec/autorun'
+
+require 'rubygems'
+require 'webmock/rspec'
+include WebMock
+WebMock.disable_net_connect!
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: awsborn
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- David Vrensk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-13 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 10
+        - 0
+        version: 1.10.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 1
+        version: 0.9.1
+  type: :development
+  version_requirements: *id003
+description: Awsborn defines servers as instances with a certain disk volume, which makes it easy to restart missing servers.
+email: david@icehouse.se
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.mdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.mdown
+- Rakefile
+- VERSION
+- lib/awsborn.rb
+- lib/awsborn/awsborn.rb
+- lib/awsborn/ec2.rb
+- lib/awsborn/extensions/object.rb
+- lib/awsborn/extensions/proc.rb
+- lib/awsborn/known_hosts_updater.rb
+- lib/awsborn/server.rb
+- lib/awsborn/server_cluster.rb
+- spec/awsborn_spec.rb
+- spec/server_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/icehouse/awsborn
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Awsborn lets you define and launch a server cluster on Amazon EC2.
+test_files: 
+- spec/awsborn_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb