gistfile1.rb

require 'ubuntu_ami'
require 'awesome_print'
require 'chef/knife/ec2_server_create'
require 'trollop'

def convert_input(arguments)
  arguments.reject do |option|
    option !~ /^[a-z]+:[a-z]{2,}-*[a-z]*-*\d*$/
  end.map do |option|
    opt, value = option.split(':')
    [ '--' + opt, value ]
  end.flatten
end

parser = Trollop::Parser.new do
  opt :region, "Region to use", :default => "eu-west-1"
  opt :release, "Release name", :default => "lucid"
  opt :group, "Security group", :default => "default"
  opt :size, "Size of instance", :default => "small"
  opt :key, "Name of AWS keypair", :default => "gsg-opseng"
  opt :ebs, "Should the instance be EBS backed?", :default => "no"
  opt :number, "How many instances should be spun up", :default => "1"
end

@opts = Trollop::with_standard_exception_handling parser do
  converted_args = convert_input(ARGV)
  if converted_args.empty?
    raise Trollop::HelpNeeded
  end
  o = parser.parse converted_args 
  o
end

def select_hostname
  available_hosts = search(:hostnames, 'NOT status:TAKEN').map do |hostname| 
    hostname['id']
  end

  return available_hosts[rand(available_hosts.size)]
end

def select_ami(release)
  ami_generator = UbuntuAmi.new(release)
  region = ami_generator.region_fix(@opts[:region])
  size = "_" + @opts[:size] 
  ebs = @opts[:ebs] == 'no' ? "" : "_ebs" 
  key = region + size + ebs
  return ami_generator.run[key]
end

def convert_size_to_flavour(size)
  return "m1." + size 
end

def bootstrap(server, nodename)
  bootstrap = Chef::Knife::Bootstrap.new
  bootstrap.name_args = [server.dns_name]
  bootstrap.config[:run_list] = [] 
  bootstrap.config[:ssh_user] = 'ubuntu' 
  bootstrap.config[:identity_file] = Chef::Config[:knife][:identity_file]
  bootstrap.config[:chef_node_name] = nodename 
  bootstrap.config[:use_sudo] = true
  puts "Woo! Yeah! Bootstrapping action about to take place!!!"
  ap bootstrap.config
  return bootstrap      
end 

def test_with_ssh(server_name, ssh_command)
  ssh = Chef::Knife::Ssh.new
  ssh.name_args = [ server_name, ssh_command ]
  ssh.config[:ssh_user] = 'ubuntu' 
  #ssh.config[:identity_file] = Chef::Config[:knife][:identity_file]
  ssh.config[:identity_file] = '/Users/stephen/Dropbox/Sony/id_rsa-gsg-opseng' 
  ssh.config[:manual] = true
  puts "Testing with ssh....."
  ssh.run
end


connection = Fog::AWS::Compute.new(
  :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
  :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
  :region => @opts[:region] 
)   

server = connection.servers.create(
  :image_id => select_ami(@opts[:release]),
  :groups => [ @opts[:group] ],
  :flavor_id => convert_size_to_flavour(@opts[:size]),
  :key_name => @opts[:key],
  :availability_zone => Chef::Config[:knife][:aws_availability_zone]
)

puts "Instance ID: #{server.id}"
puts "Flavour: #{server.flavor_id}"
puts "Image: #{server.image_id}"
puts "Availability Zone: #{server.availability_zone}"
puts "Security Groups: #{server.groups.join(", ")}"
puts "SSH Key: #{server.key_name}"

print "\nWaiting for server"
server.wait_for { print "."; ready? }
puts("\n")

puts "Public DNS Name: #{server.dns_name}"
puts "Public IP Address: #{server.ip_address}"
puts "Private DNS Name: #{server.private_dns_name}"
puts "Private IP Address: #{server.private_ip_address}"

nodename = select_hostname

#puts "Bootstrapping server with nodename: #{nodename}"
#bootstrap(server, nodename).run

test_with_ssh(server.dns_name, 'uname -a')
exit 0