snippet.rb

class Aws

  require 'fog'
  require 'logger'
  require 'erubis'
  require 'json'

  def initialize(opts={})

    opts={
      :ami_id             =>'ami-1bb67e72',
      :flavor_id          =>'m1.large',
      :username           =>'root',
      :availability_zone  => 'us-east-1a'
    }.merge!(opts)

    @ami_id                 = opts[:ami_id]
    @username               = opts[:username]
    @key_name               = opts[:key_name]
    @key_path               = opts[:key_path]
    @flavor_id              = opts[:flavor_id]
    @server_url             = opts[:server_url]
    @validation_key         = opts[:validation_key]
    @availability_zone      = opts[:availability_zone]
    @validation_client_name = opts[:validation_client_name]

    @compute = Fog::Compute.new({
      :provider              => 'AWS',
      :aws_access_key_id     =>  opts[:access_key_id],
      :aws_secret_access_key =>  opts[:secret_access_key]
    })

    if opts[:mock] == true
      Fog.mock!
    end

    unless $logger
      $logger = Logger.new(STDOUT)
      $logger.level = Logger::DEBUG
    end

  end

  def find(tag,value)
    @compute.servers.all.select {|s| s.state == "running"}.select{|t| t.tags[tag] == value}
  end

  def create_server(opts = {})

    hostname  = opts[:hostname]
    domain    = opts[:domain]
    fqdn      = [hostname, domain].join '.'

    opts={
      :ami_id                 => @ami_id,
      :key_name               => @key_name,
      :flavor_id              => @flavor_id,
      :availability_zone      => @availability_zone,
      :validation_client_name => @validation_client_name,
      :run_list               => []
    }.merge!(opts)

    instance = @compute.servers.create({
      :image_id           =>  opts[:ami_id],
      :key_name           =>  opts[:key_name],
      :flavor_id          =>  opts[:flavor_id],
      :availability_zone  =>  opts[:availability_zone],
      :groups             =>  opts[:security_groups]
    })


    $logger.info "Launching #{fqdn}: #{instance.wait_for { ready? }}"
    $logger.info "---------------------------------------------"
    $logger.info "Chef client instance id: " + instance.id
    $logger.info "Chef client IP: #{instance.public_ip_address}"
    $logger.info "Chef client ec2 DNS: #{instance.dns_name}"

    if opts[:tags]

      unless opts[:tags].has_key?(:name)
        @compute.tags.create :key=> 'Name', :value=>hostname, :resource_id => instance.id
      end

      opts[:tags].each_pair do |key,val|
        @compute.tags.create :key => key.capitalize, :value => val, :resource_id => instance.id
      end

    end

    eruby = Erubis::Eruby.new(File.read("#{File.join(File.dirname(__FILE__),'..','bootstrap')}/centos.erb"))

    userdata = eruby.result({
      :validation_client_name => opts[:validation_client_name],
      :validation_key         => @validation_key,
      :environment            => opts[:environment],
      :server_url             => @server_url,
      :hostname               => opts[:hostname],
      :domain                 => opts[:domain],
      :run_list               => opts[:run_list],
      :private_ip_address     => instance.private_ip_address
    })
    # Wait for server to ACTUALLY start, since 'instance.wait_for { ready? }'
    # actually only reports the succesfully provisioning of the instance,
    # not when things like SSH are actually started

    sleep 30

    ssh_session = @compute.servers.get instance.id

    ssh_session.username = @username
    ssh_session.private_key_path = @key_path

    counter = 0
    begin
      $logger.info "Sending userdata to #{hostname} - User: #{@username}" if counter.eql?(0)
      ssh_session.ssh userdata
    rescue Errno::ECONNREFUSED
      counter+=1
      $logger.info "Host: #{hostname} not ready, sleeping 10 seconds"
      sleep 10
      retry
    rescue Errno::ETIMEDOUT
      counter+=1
      $logger.info "Host: #{hostname} not ready, sleeping 10 seconds"
      sleep 10
      retry
    end
    $logger.info "Finished Bootstrap - {:id=>#{instance.id},:hostname=>#{fqdn}}"
    return instance
  end
end