aws-carb 0.0.3

data/lib/aws-carb/monkey_patches.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+# monkeypatch shell spinner to fix some bugs..
+
+module ShellSpinner
+  class Runner
+    def wrap_block(text = nil, colorize = true, &block)
+      with_message(text) { with_spinner(&block) }
+    end
+
+    private
+
+    # FIXME: better way to disable colours?
+    #colorize = colorize ? lambda { |s,c| s.colorize(c) } : lambda { |s,c| s }
+    #colorize.call(s, :red)
+
+    def with_message(text = nil, colorize = false)
+      begin
+        print "#{text}... " unless text.nil?
+
+        catch_user_output { yield }
+
+        print "done\n".colorize(:green) unless text.nil?
+
+        print user_output.colorize(:blue)
+
+      rescue Exception => e
+        print "\bfail\n".colorize(:red) unless text.nil?
+
+        print user_output.colorize(:blue)
+
+        re_raise_exception e
+      end
+    end
+  end
+end
+
+def ShellSpinner(text = nil, colorize = true, &block)
+  runner = ShellSpinner::Runner.new
+
+  runner.wrap_block(text, colorize, &block)
+end
+
+# override the output from optparse to be a bit more aesthetically pleasing
+module Subcommands
+  def print_actions
+    subcommand_help = "#{'SUBCOMMAND'.colorize({:color => :white, :mode => :bold})}\n"
+
+    @commands.each_pair do |c, opt|
+      subcommand_help << "\n    #{c}              - #{opt.call.description}"
+    end
+
+    unless @aliases.empty?
+      subcommand_help << "\n\naliases: \n"
+      @aliases.each_pair { |name, val| subcommand_help << "   #{name} - #{val}\n"  }
+    end
+
+    subcommand_help << "\n\n    help <command>      - for more information on a specific command\n\n"
+  end
+
+  def command *names
+    name = names.shift
+
+    @commands ||= {}
+    @aliases  ||= {}
+
+    names.each { |n| @aliases[n.to_s] = name.to_s } if names.length > 0
+
+    opt = lambda do
+      OptionParser.new do |opts|
+        yield opts
+        opts.banner << "OPTIONS"
+      end
+    end
+
+    @commands[name.to_s] = opt
+  end
+end

data/lib/aws-carb/services/ec2.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+module AWSCarb
+  module Services
+    class Ec2
+
+      include Singleton
+
+      attr_reader :instance
+
+      def client(config)
+        @config = config
+        @instance = nil
+
+        ShellSpinner "# configuring ec2 session", false do
+          begin
+            @client = AWS::EC2.new(config[:ec2])
+            @client.regions[@config.find_with_context(:region, :ec2)]
+            puts
+          rescue => e
+            puts "error: failed to create ec2 session, check that you're using a valid region!"
+            die e
+          end
+        end
+      end
+
+      def create_instance
+
+        instance = nil
+
+        ShellSpinner "# creating instance", false do
+
+          # FIXME: this is naff
+
+          begin
+            allowed_ec2_parameters = [
+              :count,
+              :iam_instance_profile,
+              :block_device_mappings,
+              :virtual_name,
+              :device_name,
+              :ebs,
+              :snapshot_id,
+              :volume_size,
+              :delete_on_termination,
+              :volume_type,
+              :iops,
+              :no_device,
+              :monitoring_enabled,
+              :availability_zone,
+              :image_id,
+              :key_name,
+              :key_pair,
+              :security_groups,
+              :security_group_ids,
+              :user_data,
+              :instance_type,
+              :kernel_id,
+              :ramdisk_id,
+              :disable_api_termination,
+              :instance_initiated_shutdown_behavior,
+              :subnet,
+              :private_ip_address,
+              :dedicated_tenancy,
+              :ebs_optimized,
+            ]
+
+            ec2_config = {}
+
+            allowed_ec2_parameters.each do |param|
+              ec2_config[param] = @config[:ec2][param] if @config[:ec2][param]
+            end
+
+            @instance = @client.instances.create(ec2_config)
+          rescue => e
+            puts "# failed to create new ec2 instance:"
+            die e
+          end
+        end
+
+        puts
+
+        ShellSpinner "# awaiting build completion", false do
+          sleep 1 until @instance.status != :pending
+        end
+
+        puts
+
+        ShellSpinner "# awaiting running state", false do
+          sleep 1 until @instance.status == :running
+        end
+
+        puts
+      end
+    end
+  end
+end

data/lib/aws-carb/services/route53.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+module AWSCarb
+  # named so as not to clash with AWS module from aws-sdk
+  module Services
+    class Route53
+
+      include Singleton
+
+      def client(config)
+        @config = config
+
+        begin
+          ShellSpinner "# configuring route53 session", false do
+            @client = ::AWS::Route53.new(@config[:route53])
+          end
+
+          puts
+        rescue => e
+          puts "error: failed to create route53 session"
+          die e
+        end
+      end
+
+      def check_hostname_and_domain_availability
+
+        ShellSpinner "# checking to see if hostname and domain have been configured", false do
+
+          if @config[:route53].andand[:new_dns_records]
+
+          else
+            debug "# skipping route53 check since either hostname or domain wasn't found:"
+            debug "hostname not found" if hostname.nil?
+            debug "domain not found"   if domain.nil?
+            debug
+          end
+        end
+
+        puts
+
+        return unless @config[:route53].andand[:new_dns_records]
+
+        ShellSpinner "# checking to see if record exists", false do
+          begin
+            record_sets = @client.hosted_zones[@config[:route53][:zone]].resource_record_sets
+
+            @config[:route53][:new_dns_records].each_value do |record|
+              die "error: record already exists: #{record[:alias]}" if record_sets[record[:alias], 'CNAME'].exists?
+            end
+          rescue => e
+            puts "# could not check to see if DNS records exist:"
+            die e
+          end
+        end
+
+        puts
+      end
+
+      def create_records(ec2)
+        if @config[:route53][:new_dns_records].nil?
+          debug "# skipping creation of new records on route53"
+          debug
+          return
+        end
+
+        ShellSpinner "# updating route53 with new CNAMES for host", false do
+
+          @config[:route53][:new_dns_records][:public][:target]  = ec2.instance.public_dns_name
+          @config[:route53][:new_dns_records][:private][:target] = ec2.instance.private_dns_name
+
+          record_sets = @client.hosted_zones[@config[:route53][:zone]].resource_record_sets
+
+          @config[:route53][:new_dns_records].each do |record_scope, record|
+            new_record = record_sets[record[:alias], 'CNAME']
+
+            raise "error: '#{record_scope}' record already exists: #{record[:alias]}" if new_record.exists?
+
+            record_sets.create(record[:alias], 'CNAME', :ttl => @config[:route53][:ttl], :resource_records => [{:value => record[:target]}])
+          end
+        end
+
+        puts
+      end
+    end
+  end
+end

data/lib/aws-carb/user_data.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+module AWSCarb
+  class UserData
+
+    include Singleton
+
+    attr_accessor :combined_user_data
+
+    def create(config)
+      user_data_template_resolved = resolve_template(config)
+      @combined_user_data         = combine_user_data(config, user_data_template_resolved)
+      @user_data_template         = nil
+      @resolved_template          = nil
+    end
+
+    def resolve_template(config)
+
+      # FIXME: blank templates / empty templates / no template should work..
+
+      return nil unless config[:ec2] and config[:user_data_template][:file]
+
+      ShellSpinner "# loading template", false do
+        begin
+          template_file = config[:user_data_template][:file]
+
+          raise ArgumentError, "no such file: #{template_file}" unless File.exist?(template_file)
+
+          @user_data_template = File.read(template_file)
+        rescue => e
+          puts "# unable to open template file:"
+          die e
+        end
+      end
+
+      puts
+
+     ShellSpinner "# parsing template"  do
+        begin
+          @resolved_template = Erubis::Eruby.new(@user_data_template).result(config[:user_data_template_variables])
+        rescue => e
+          puts "# failed to resolve variables in user_data_template:"
+          ap e.class
+          die e
+        end
+      end
+
+      puts
+
+      return @resolved_template
+    end
+
+    def combine_user_data(config, user_data_template_resolved)
+
+      # if user_data_template and user_data are supplied then combine them, otherwise just
+      # use user_data (which is empty by default)
+      begin
+        if config[:ec2].andand[:user_data]
+          user_data = config[:ec2][:user_data]
+        end
+
+        if ! user_data_template_resolved.nil? and ! user_data.nil?
+          puts "# combining user_data with user_data_template"
+          user_data = user_data_template_resolved + user_data
+          puts
+        elsif ! user_data_template_resolved.nil? and user_data.nil?
+          debug "# no raw user_data parsed in"
+          user_data = user_data_template_resolved
+          debug
+        elsif user_data.nil?
+          debug "# no user_data or user_data_template specified on the command line"
+          user_data = ""
+          debug
+        else
+          debug "# using user_data from cli argument"
+          debug
+        end
+
+      rescue => e
+        puts "# failed to combine user_data!"
+        die e
+      end
+
+      return user_data
+    end
+
+    def display
+      return if @combined_user_data.nil?
+
+      puts "# --- beginning of user_data ---"
+      puts
+      begin
+        puts @combined_user_data
+      rescue => e
+        puts "error: could not display user_data!"
+        puts e
+      end
+      puts
+      puts "# --- end of user_data ---"
+      puts
+    end
+  end
+end

data/lib/aws-carb/version.rb

@@ -0,0 +1,3 @@
+module AWSCarb
+  VERSION = "0.0.3"
+end

data/lib/aws-carb.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require 'aws-sdk'
+require 'yaml'
+require 'erubis'
+require 'awesome_print'
+require 'securerandom'
+require 'shell-spinner'
+require 'active_support/core_ext/string/strip'
+require 'active_support/core_ext/hash/keys'
+require 'ostruct'
+require 'subcommand'
+require 'singleton'
+require 'andand'
+require 'colorize'
+
+# module is broken up into:
+#
+# AWSCarb.*                  - main methods
+# AWSCarb::CliArugmentParser - argument parsing
+# AWSCarb::Config            - argument checking / config checking
+# AWSCarb::UserData          - parse user data template and possibly combine with user_data cli arg
+# AWSCarb::Services::Ec2     - build an ec2 instance
+# AWSCarb::Services::Route53 - create dns records in route53
+#
+
+if ! $stdout.tty?
+  String.class_eval do
+    def colorize(args)
+      self
+    end
+  end
+end
+
+module AWSCarb
+  def self.banner
+    banner = <<-HEREDOC.strip_heredoc
+
+       ::::::::      :::     :::::::::  :::::::::  
+      :+:    :+:   :+: :+:   :+:    :+: :+:    :+: 
+      +:+         +:+   +:+  +:+    +:+ +:+    +:+ 
+      +#+        +#++:++#++: +#++:++#:  +#++:++#+  
+      +#+        +#+     +#+ +#+    +#+ +#+    +#+ 
+      #+#    #+# #+#     #+# #+#    #+# #+#    #+# 
+       ########  ###     ### ###    ### #########  
+
+          - cloudinit and route53 bootstrap -
+
+    HEREDOC
+
+    indent = ' ' * 6
+
+    puts banner.each_line.map { |line| indent + line }
+  end
+
+  def self.run
+
+    #
+    # configuration
+    #
+
+    # parse cli args
+    cli_arguments = CliArgumentParser.parse
+
+    # display banner on successful cli argument parsing..
+    banner
+
+    # create a configuration based on our various data sources..
+    @config = Config.instance
+    @config.create(cli_arguments)
+    @config.display if $GLOBAL_VERBOSE
+
+    # load erb template and parse the template with user_data_template_variables
+    # then merge user_data template with raw user_data (if provided) -
+    # end up single user_data ready to pass into ec2 instance..
+    @user_data = UserData.instance
+    @user_data.create(@config)
+    @user_data.display if @config[:user_data_template][:file] and ($GLOBAL_VERBOSE or @config[:show_parsed_template])
+
+    #
+    # aws interaction
+    # 
+
+    if @config[:route53].andand[:new_dns_records]
+      @route53 = Services::Route53.instance
+      @route53.client(@config)
+      @route53.check_hostname_and_domain_availability
+    end
+
+    ## initialize ec2 object with credentials
+    @ec2 = Services::Ec2.instance
+    @ec2.client(@config)
+    @ec2.create_instance
+
+    if @config[:route53].andand[:new_dns_records]
+      @route53.create_records(@ec2)
+    end
+
+    #
+    # summary
+    # 
+
+    show_instance_details
+  end
+
+  def self.show_instance_details
+    puts <<-HEREDOC.strip_heredoc
+      # instance details:
+      id:               #{@ec2.instance.id}
+      public ip:        #{@ec2.instance.public_ip_address}
+      public aws fqdn:  #{@ec2.instance.public_dns_name}
+      private ip:       #{@ec2.instance.private_ip_address}
+      private aws fqdn: #{@ec2.instance.private_dns_name}
+    HEREDOC
+
+    unless @config[:route53][:new_dns_records].nil?
+      puts <<-HEREDOC.strip_heredoc
+        public fqdn:      #{@config[:route53][:new_dns_records][:public][:alias]}
+        private fqdn:     #{@config[:route53][:new_dns_records][:private][:alias]}
+      HEREDOC
+    end
+
+    puts <<-HEREDOC.strip_heredoc
+      
+      # connect: 
+      ssh #{@ec2.instance.dns_name} -l ubuntu
+    HEREDOC
+  end
+end

data/templates/basic.cloud-config.erb

@@ -0,0 +1,84 @@
+#cloud-config
+
+# the above line is required by cloud init
+
+<%- if defined?(hostname) %>
+hostname: <%= hostname %>
+fqdn: <%= hostname -%>.<%= domain %>
+<% end %>
+
+<%- if defined?(ssh_keys) %>
+ssh_authorized_keys:
+  <% ssh_keys.each do |key| %>
+  - <%= key %>
+  <% end %>
+<% end %>
+
+bootcmd:
+  - echo "deb http://<%= repository_server -%>/debian/ <%= debian_distro -%> main" >> /etc/apt/<%= apt_source_name -%>.list.d/<% apt_source_name -%>.list
+
+package_upgrade: true
+
+manage_etc_hosts: true
+
+packages:
+  - puppet
+  - facter
+  - lsb-release
+
+  # required by aws-sdk
+  - ruby1.9.1
+  - ruby1.9.1-dev
+  - libxml2-dev
+  - build-essential
+
+  # required by awscli
+  - python-pip
+
+
+puppet:
+  conf:
+    main:
+      logdir: /var/log/puppet
+      vardir: /var/lib/puppet
+      rundir: /var/run/puppet
+      ssldir: /etc/puppet/ssl
+      confdir: /etc/puppet
+      pluginsync: true
+      factpath: /var/lib/puppet/lib/facter:/var/lib/puppet/facts
+    agent:
+      server: <%= puppet_master %>
+      ca_server: <%= ca_server %>
+      configtimeout: 600
+      preferred_serialization_format: marshal
+
+runcmd:
+  - service puppet stop
+  - puppet agent --onetime --no-daemonize -v > /var/log/puppet-initial_run.log
+  - update-alternatives --set ruby /usr/bin/ruby1.9.1
+  - update-alternatives --set gem /usr/bin/gem1.9.1
+
+  # building the native extensions for this gem takes a long time,
+  # if you reboot the machine soon after machine creation
+  # then this gem may not have finished installing and your
+  # DNS will not get updated on boot.
+  - gem install aws-sdk facter --no-ri --no-rdoc
+
+  # script to update route53 dynamic dns configuration on boot..
+
+  - pip install awscli
+
+  # filthy hack..
+  - mkdir /root/.aws
+  - echo '[profile s3]' >> /root/.aws/config
+  - echo 'aws_access_key_id = <%= s3_access_key_id %>' >> /root/.aws/config
+  - echo 'aws_secret_access_key = <%= s3_secret_access_key %>' >> /root/.aws/config
+  - echo 'region = <%= s3_region %>' >> /root/.aws/config
+
+  # update route53 on boot
+  # available at: https://github.com/roobert/route53-dynamic_dns_update
+  - aws s3 --profile s3 cp --region us-east-1 s3://<%= s3_bucket -%>.cloudinit/aws-route53.conf /etc/aws-route53.conf
+  - aws s3 --profile s3 cp --region us-east-1 s3://<%= s3_bucket -%>.cloudinit/route53-dynamic_dns_update.rb /usr/local/bin/route53-dynamic_dns_update.rb
+  - chmod 400 /etc/aws-route53.conf
+  - chmod 755 /usr/local/bin/route53-dynamic_dns_update.rb
+  - echo '/usr/local/bin/route53-dynamic_dns_update.rb' > /etc/rc.local