knife-instance 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in knife-instance.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 ZestFinance
+
+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.md

@@ -0,0 +1,46 @@
+# knife-instance [![Code Climate](https://codeclimate.com/github/ZestFinance/knife-instance.png)](https://codeclimate.com/github/ZestFinance/knife-instance) [![Build Status](https://travis-ci.org/ZestFinance/knife-instance.png)](https://travis-ci.org/ZestFinance/knife-instance)
+
+Manage EC2 instances with Chef from the command line
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'knife-instance'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install knife-instance
+
+## Configuration
+
+Add this to your environment ~/.bashrc or ~/.zshrc
+
+```shell
+export aws_access_key_id='Put your key here'
+export aws_secret_access_key='Put your key here'
+```
+
+## Usage
+
+```shell
+bundle exec knife instance create -E development \
+  --image my_ec2-image \
+  -t myclustertag \
+  --group my_security_group
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/ZestFinance/knife-instance/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Credits
+Inspired by [knife-ec2 gem](https://github.com/opscode/knife-ec2)

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--color'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task default: :spec

data/knife-instance.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knife-instance/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "knife-instance"
+  spec.version       = Knife::Instance::VERSION
+  spec.authors       = ["Alexander Tamoykin", "Val Brodsky"]
+  spec.email         = ["at@zestfinance.com", "vlb@zestfinance.com"]
+  spec.summary       = %q{Manage EC2 instances with Chef from the command line}
+  spec.description   = %q{Manage EC2 instances with Chef from the command line}
+  spec.homepage      = "https://github.com/ZestFinance/knife-instance"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'chef', '>= 0.10.24'
+  spec.add_dependency 'fog', '>= 1.9.0'
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "require_all"
+end

data/lib/chef/knife/instance_create.rb

@@ -0,0 +1,202 @@
+require "knife-instance/zestknife"
+
+class Chef
+  class Knife
+    class InstanceCreate < ::ZestKnife
+      banner "knife instance create (options)"
+
+      deps do
+        require 'fog'
+        require 'fog/aws/models/dns/record'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/node'
+        require 'chef/api_client'
+      end
+
+      attr_accessor :hostname
+
+      with_opts :aws_ssh_key_id, :encrypted_data_bag_secret, :wait_for_it
+      with_validated_opts :cluster_tag, :environment, :base_domain, :region
+
+      option :flavor,
+             :short => "-f FLAVOR",
+             :long => "--flavor FLAVOR",
+             :description => "The flavor of server (m1.small, m1.medium, etc)",
+             :default => "m1.small"
+
+      option :image,
+             :short => "-I IMAGE",
+             :long => "--image IMAGE",
+             :description => "The AMI for the server"
+
+      option :iam_role,
+             :long => "--iam-role IAM_ROLE",
+             :description => "Assign a node to an IAM Role. Set to 'default_role' by default",
+             :default => 'default_role'
+
+      option :security_groups,
+             :short => "-G X,Y,Z",
+             :long => "--groups X,Y,Z",
+             :description => "The security groups for this server"
+
+      option :availability_zone,
+             :short => "-Z ZONE",
+             :long => "--availability-zone ZONE",
+             :description => "The Availability Zone"
+
+      option :hostname,
+             :short => "-h NAME",
+             :long => "--node-name NAME",
+             :description => "The Chef node name for your new node"
+
+      option :run_list,
+             :short => "-r RUN_LIST",
+             :long => "--run-list RUN_LIST",
+             :description => "(Required) Comma separated list of roles/recipes to apply",
+             :default => ["role[base]"],
+             :proc => lambda { |o| o.split(/[\s,]+/) }
+
+      option :show_server_options,
+             :short => "-D",
+             :long => "--server-dry-run",
+             :description => "Show the options used to create the server and exit before running",
+             :boolean => true,
+             :default => false
+
+      def run
+        $stdout.sync = true
+        setup_config
+
+        @environment = config[:environment]
+        @base_domain = config[:base_domain]
+        @hostname    = config[:hostname] || generate_hostname(@environment)
+        @color       = config[:cluster_tag]
+        @region      = config[:region]
+
+        validate!
+
+        get_user_data
+
+        if config[:show_server_options]
+          details = create_server_def
+          ui.info(
+              ui.color("Creating server with options\n", :bold) +
+                  ui.color(JSON.pretty_generate(details.reject { |k, v| k == :user_data }), :blue) +
+                  ui.color("\nWith user script\n", :bold) +
+                  ui.color(details[:user_data], :cyan)
+          )
+          exit 0
+        end
+
+        server = ZestKnife.aws_for_region(@region).compute.servers.create(create_server_def)
+
+        msg_pair("Zest Hostname", fqdn(hostname))
+        msg_pair("Environment", @environment)
+        msg_pair("Run List", config[:run_list].join(', '))
+        msg_pair("Instance ID", server.id)
+        msg_pair("Flavor", server.flavor_id)
+        msg_pair("Image", server.image_id)
+        msg_pair("Region", @region)
+        msg_pair("Availability Zone", server.availability_zone)
+        msg_pair("Security Groups", server.groups.join(", "))
+        msg_pair("SSH Key", server.key_name)
+
+        return unless config[:wait_for_it]
+
+        print "\n#{ui.color("Waiting for server", :magenta)}"
+
+        # wait for it to be ready to do stuff
+        server.wait_for { print "."; ready? }
+
+        puts "\n"
+        msg_pair("Public DNS Name", server.dns_name)
+        msg_pair("Public IP Address", server.public_ip_address)
+        msg_pair("Private DNS Name", server.private_dns_name)
+        msg_pair("Private IP Address", server.private_ip_address)
+        msg_pair("Instance ID", server.id)
+        msg_pair("Flavor", server.flavor_id)
+        msg_pair("Image", server.image_id)
+        msg_pair("Region", @region)
+        msg_pair("Availability Zone", server.availability_zone)
+        msg_pair("Security Groups", server.groups.join(", "))
+        msg_pair("SSH Key", server.key_name)
+        msg_pair("Root Device Type", server.root_device_type)
+
+        zone.records.create(:name => fqdn(hostname), :type => 'A', :value => server.private_ip_address, :ttl => 300)
+
+        server
+      end
+
+      def self.new_with_defaults environment, region, color, base_domain, opts
+        new.tap do |ic|
+          ic.config[:environment]               = environment
+          ic.config[:cluster_tag]               = color
+          ic.config[:region]                    = region
+          ic.config[:base_domain]               = base_domain
+          ic.config[:aws_ssh_key_id]            = opts[:aws_ssh_key_id]
+          ic.config[:aws_access_key_id]         = opts[:aws_access_key_id]
+          ic.config[:aws_secret_access_key]     = opts[:aws_secret_access_key]
+          ic.config[:availability_zone]         = opts[:availability_zone]
+          ic.config[:encrypted_data_bag_secret] = opts[:encrypted_data_bag_secret]
+          ic.config[:wait_for_it]               = opts[:wait_for_it]
+          ic.config[:image]                     = opts[:image]
+        end
+      end
+
+      def create_server_def
+        server_def = {
+            :image_id => image,
+            :groups => security_group,
+            :flavor_id => config[:flavor],
+            :key_name => config[:aws_ssh_key_id],
+            :availability_zone => availability_zone,
+            :tags => {
+                'Name' => hostname,
+                'environment' => @environment
+            },
+            :user_data => config[:without_user_data] ? "" : get_user_data,
+            :iam_instance_profile_name => config[:iam_role]
+        }
+
+        server_def
+      end
+
+      def image
+        config[:image]
+      end
+
+      def security_group
+        config[:security_groups]
+      end
+
+      def availability_zone
+        config[:availability_zone]
+      end
+
+      def ami
+        @ami ||= ZestKnife.aws_for_region(@region).compute.images.get(image)
+      end
+
+      def validate!
+        unless File.exists?(config[:encrypted_data_bag_secret])
+          errors << "Could not find encrypted data bag secret. Tried #{config[:encrypted_data_bag_secret]}"
+        end
+
+        if ami.nil?
+          errors << "You have not provided a valid image. Tried to find '#{image}'."
+        end
+
+        validate_hostname hostname
+
+        super([:aws_access_key_id, :aws_secret_access_key,
+               :flavor, :aws_ssh_key_id, :run_list])
+      end
+
+      def get_user_data
+        generator = Zest::BootstrapGenerator.new(Chef::Config[:validation_key], Chef::Config[:validation_client_name], Chef::Config[:chef_server_url], @environment, config[:run_list], hostname, @color, @base_domain, config[:encrypted_data_bag_secret])
+        generator.generate
+      end
+    end
+  end
+end

data/lib/knife-instance.rb

@@ -0,0 +1,2 @@
+require 'knife-instance'
+require 'chef/knife/instance_create'

data/lib/knife-instance/aws.rb

@@ -0,0 +1,37 @@
+require 'fog'
+Excon.defaults[:ssl_verify_peer] = false
+
+module Zest
+  class AWS
+    attr_accessor :aws_access_key_id, :aws_secret_access_key, :region
+
+    def initialize aws_access_key_id, aws_secret_access_key, region
+      @aws_access_key_id, @aws_secret_access_key, @region = aws_access_key_id, aws_secret_access_key, region
+    end
+
+    def compute
+      @compute ||= begin
+        Fog::Compute.new(
+          :provider => 'AWS',
+          :aws_access_key_id => aws_access_key_id,
+          :aws_secret_access_key => aws_secret_access_key,
+          :region => region
+        )
+      end
+    end
+
+    def servers
+      @servers ||= compute.servers
+    end
+
+    def dns
+      @dns ||= begin
+        Fog::DNS.new(
+          :provider => 'AWS',
+          :aws_access_key_id => aws_access_key_id,
+          :aws_secret_access_key => aws_secret_access_key
+        )
+      end
+    end
+  end
+end

data/lib/knife-instance/bootstrap_generator.rb

@@ -0,0 +1,59 @@
+# This class generates the ec2 user-data bootstrap script
+module Zest
+  class BootstrapGenerator
+    CONFIG_FILE_TEMPLATE = File.expand_path 'templates/boot.sh.erb', File.dirname(__FILE__)
+
+    def initialize(validation_key_file, validation_client_name, chef_server_url, environment, run_list, hostname, color, base_domain, encrypted_databag_secret_file)
+      @validation_client_name = validation_client_name
+      @validation_key_file = validation_key_file
+      @chef_server_url = chef_server_url
+      @environment = environment
+      @run_list = run_list
+      @hostname = hostname
+      @color = color
+      @base_domain = base_domain
+      @encrypted_databag_secret_file = encrypted_databag_secret_file
+    end
+
+    def first_boot
+      {
+        "run_list"          => @run_list,
+        "assigned_hostname" => @hostname,
+        "rails"             => {"cluster" => {"color" => @color}},
+        "base_domain"       => @base_domain
+      }.to_json
+    end
+
+    def validation_key
+      File.read(@validation_key_file)
+    end
+
+    def encrypted_data_bag_secret
+      File.read @encrypted_databag_secret_file
+    end
+
+    def generate
+      template = File.read(CONFIG_FILE_TEMPLATE)
+      Erubis::Eruby.new(template).evaluate(self)
+    end
+
+    def config_content
+      <<-CONFIG
+  require 'syslog-logger'
+  Logger::Syslog.class_eval do
+    attr_accessor :sync, :formatter
+  end
+
+  log_level              :info
+  log_location           Logger::Syslog.new("chef-client")
+  chef_server_url        "#{@chef_server_url}"
+  validation_client_name "#{@validation_client_name}"
+  node_name              "#{@hostname}"
+  CONFIG
+    end
+
+    def start_chef
+      "/usr/bin/chef-client -j /etc/chef/first-boot.json -E #{@environment}"
+    end
+  end
+end

data/lib/knife-instance/templates/boot.sh.erb

@@ -0,0 +1,55 @@
+#!/bin/bash
+exec > >(tee /var/log/user-data.log|logger -t chef-client -s 2>/dev/console) 2>&1
+
+set -e -x
+
+if [ ! -f /usr/bin/chef-client ]; then
+  apt-get update
+  apt-get install -y ruby ruby1.8-dev build-essential wget libruby-extras libruby1.8-extras
+  cd /tmp
+  wget http://production.cf.rubygems.org/rubygems/rubygems-1.8.10.tgz
+  tar zxf rubygems-1.8.10.tgz
+  cd rubygems-1.8.10
+  ruby setup.rb --no-format-executable
+  cd ..
+  rm -Rf /tmp/rubygems-1.8.10
+fi
+
+gem update --no-rdoc --no-ri
+gem install ohai --no-rdoc --no-ri --verbose
+gem install mime-types --no-rdoc --no-ri --verbose --version 1.25
+gem install chef --no-rdoc --no-ri --verbose --version 10.24.0
+gem install tzinfo --no-rdoc --no-ri --verbose --version 0.3.33
+gem install syslog-logger --no-rdoc --no-ri --verbose --version 1.6.8
+
+mkdir -p /etc/chef
+
+<%# Remember to suppress a newline at the end of an erb statement for keys --> -%>
+
+(
+cat <<'EOP'
+<%= validation_key -%>
+EOP
+) > /tmp/validation.pem
+awk NF /tmp/validation.pem > /etc/chef/validation.pem
+rm /tmp/validation.pem
+
+(
+cat <<'EOP'
+<%= config_content %>
+EOP
+) > /etc/chef/client.rb
+
+(
+cat <<'EOP'
+<%= first_boot %>
+EOP
+) > /etc/chef/first-boot.json
+
+(
+cat <<'EOP'
+<%= encrypted_data_bag_secret -%>
+EOP
+) > /etc/chef/encrypted_data_bag_secret
+
+<%= start_chef %>

data/lib/knife-instance/version.rb

@@ -0,0 +1,5 @@
+module Knife
+  module Instance
+    VERSION = "0.1.0"
+  end
+end

data/lib/knife-instance/zestknife.rb

@@ -0,0 +1,278 @@
+require 'chef/knife'
+require 'knife-instance/aws'
+require 'knife-instance/bootstrap_generator'
+
+class ZestKnife < Chef::Knife
+  attr_accessor :base_domain
+  attr_accessor :internal_domain
+
+  def msg_pair(label, value, color=:cyan)
+    if value && !value.to_s.empty?
+      puts "#{ui.color(label, color)}: #{value}"
+    end
+  end
+
+  def self.aws_for_region(region)
+    Zest::AWS.new(Chef::Config[:knife][:aws_access_key_id], Chef::Config[:knife][:aws_secret_access_key], region)
+  end
+
+  def self.AWS_REGIONS
+    []
+  end
+
+  def self.in_all_aws_regions
+    self.AWS_REGIONS.each do |region|
+      yield self.aws_for_region(region)
+    end
+  end
+
+  def find_item(klass, name)
+    begin
+      object = klass.load(name)
+      return [object]
+    rescue Net::HTTPServerException
+      return []
+    end
+  end
+
+  def find_ec2(name)
+    nodes = {}
+    self.class.in_all_aws_regions do |zest_aws|
+      nodes = nodes.merge(zest_aws.compute.servers.group_by { |s| s.tags["Name"] })
+    end
+    nodes[name].nil? ? [] : nodes[name]
+  end
+
+  def find_r53 name
+    in_zone = zone_from_name(name)
+    if in_zone.nil?
+      in_zone = zone
+      name = fqdn(name)
+    end
+    name = "#{name}." unless name[-1] == "."
+    recs = in_zone.records.select {|r| r.name == name }.to_a
+    recs.empty? ? [in_zone.records.get(name)].compact : recs
+  end
+
+  def zone
+    unless @zone
+      self.class.in_all_aws_regions do |zest_aws|
+        @zone ||= zest_aws.dns.zones.detect { |z| z.domain.downcase == domain }
+      end
+      raise "Could not find DNS zone" unless @zone
+    end
+
+    @zone
+  end
+
+  def zone_from_name dns_name
+    name, tld = dns_name.split(".")[-2..-1]
+    if name && tld
+      dns_domain = "#{name}.#{tld}"
+      zone = nil
+
+      self.class.in_all_aws_regions do |zest_aws|
+        zone1 = zest_aws.dns.zones.select {|x| x.domain =~ /^#{dns_domain}/ }.first
+        zone = zone1 if zone1
+      end
+
+      zone
+    end
+  end
+
+  def fqdn(name)
+    return '' if name.nil? || name.empty?
+    "#{name}.#{domain}"
+  end
+
+  def domain
+    @internal_domain || ""
+  end
+
+  def generate_hostname env
+    name = nil
+
+    5.times do |i|
+      name = random_hostname env
+      break if check_services(name).empty?
+
+      name = nil
+      srand # re-seed rand so we don't get stuck in a sequence
+    end
+
+    errors << "Unable to find available hostname in 5 tries" if name.nil?
+    name
+  end
+
+  def validate_hostname hostname
+    errors << "hostname can't be blank" and return if (hostname.nil? || hostname.empty?)
+    check_services(hostname).each do |service|
+      errors << "#{hostname} in #{service.class} already exists. Delete first."
+    end
+  end
+
+  def check_services hostname
+    find_item(Chef::Node, hostname) +
+      find_item(Chef::ApiClient, hostname) +
+      find_ec2(hostname) +
+      find_r53(hostname)
+  end
+
+  def random_hostname env
+    "#{domain_prefix}#{environment_prefix env}#{random_three_digit_number}"
+  end
+
+  def domain_prefix
+    base_domain[0]
+  end
+
+  def environment_prefix env
+    env[0]
+  end
+
+  def random_three_digit_number
+    sprintf("%03d", rand(1000))
+  end
+
+  def self.with_opts(*args)
+    invalid_args = args.select {|arg| !OPTS.keys.include? arg }
+    raise "Invalid option(s) passed to with_opts: #{invalid_args.join(", ")}" unless invalid_args.empty?
+
+    args.each do |arg|
+      option arg, OPTS[arg]
+    end
+  end
+
+  class << self; attr_accessor :validated_opts end
+
+  def self.with_validated_opts(*args)
+    with_opts(*args)
+    validates(*args)
+  end
+
+  def self.validates(*args)
+    raise "Invalid argument(s) passed to validates: #{args - VALIDATORS.keys}" unless (args - VALIDATORS.keys).empty?
+    self.validated_opts ||= []
+    self.validated_opts.concat args
+  end
+
+  def setup_config(keys=[:aws_access_key_id, :aws_secret_access_key])
+    keys.each do |k|
+      Chef::Config[:knife][k] = ENV[k.to_s] if Chef::Config[:knife][k].nil? && ENV[k.to_s]
+    end
+  end
+
+  def errors
+    @errors ||= []
+  end
+
+  def errors?
+    !errors.empty?
+  end
+
+  def validate!(keys=[:aws_access_key_id, :aws_secret_access_key])
+    keys.each do |k|
+      if Chef::Config[:knife][k].nil? & config[k].nil?
+        errors << "You did not provide a valid '#{k}' value."
+      end
+    end
+
+    self.class.validated_opts.each do |opt|
+      send VALIDATORS[opt]
+    end if self.class.validated_opts
+
+    if errors.each { |e| ui.error(e) }.any?
+      exit 1
+    end
+  end
+
+  def validate_env
+  end
+
+  def validate_domain
+  end
+
+  def validate_region
+  end
+
+  def validate_force_deploy
+  end
+
+  def validate_color
+    unless @color
+      errors << "You must provide a cluster_tag with the -t option"
+    end
+  end
+
+  def validate_prod
+  end
+
+  OPTS = {
+    :aws_access_key_id => {
+      :short => "-A ID",
+      :long => "--aws-access-key-id KEY",
+      :description => "Your AWS Access Key ID",
+      :proc => Proc.new { |key| Chef::Config[:knife][:aws_access_key_id] = key }
+    },
+    :aws_secret_access_key => {
+      :short => "-K SECRET",
+      :long => "--aws-secret-access-key SECRET",
+      :description => "Your AWS API Secret Access Key",
+      :proc => Proc.new { |key| Chef::Config[:knife][:aws_secret_access_key] = key }
+    },
+    :cluster_tag => {
+      :short => "-t TAG",
+      :long => "--cluster-tag TAG",
+      :description => "Tag that identifies this node as part of the <TAG> cluster"
+    },
+    :environment => {
+      :short => "-E CHEF_ENV",
+      :long => "--environment CHEF_ENV",
+      :description => "Chef environment"
+    },
+    :region => {
+      :long => "--region REGION",
+      :short => '-R REGION',
+      :description => "Your AWS region",
+      :default => ENV['AWS_REGION'],
+      :proc => Proc.new { |key| Chef::Config[:knife][:region] = key }
+    },
+    :encrypted_data_bag_secret => {
+      :short => "-B FILE",
+      :long => "--encrypted_data_bag_secret FILE",
+      :description => "Path to the secret key to unlock encrypted chef data bags",
+      :default => ENV['DATABAG_KEY_PATH']
+    },
+    :aws_ssh_key_id => {
+      :short => "-S KEY",
+      :long => "--aws-ssh-key KEY",
+      :description => "AWS EC2 SSH Key Pair Name",
+      :default => ENV["aws_ssh_key"]
+    },
+    :base_domain => {
+      :long => "--base-domain DOMAIN",
+      :description => "The domain to be used for this node.",
+      :default => ENV["default_base_domain"] || ""
+    },
+     :wait_for_it => {
+      :short => "-W",
+      :long => "--wait-for-it",
+      :description => "Wait for EC2 to return extended details about the host and register DNS",
+      :boolean => true,
+      :default => false
+    },
+    :prod => {
+      :long => "--prod",
+      :description => "If the environment for your command is production, you must also pass this parameter.  This is to make it slightly harder to do something unintentionally to production."
+    }
+  }
+
+  VALIDATORS = {
+    :environment  => :validate_env,
+    :base_domain  => :validate_domain,
+    :cluster_tag  => :validate_color,
+    :prod         => :validate_prod,
+    :force_deploy => :validate_force_deploy,
+    :region       => :validate_region
+  }
+end

data/spec/lib/chef/knife/instance_create_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Chef::Knife::InstanceCreate do
+  let(:internal_domain) { 'internal.com.' }
+
+  before do
+    described_class::load_deps
+    @instance = described_class.new
+    @instance.merge_configs
+    @instance.internal_domain = internal_domain
+    #TODO: refactor
+    @instance.class.stub(:AWS_REGIONS).and_return(['some_region'])
+    @instance.config[:environment] = "development"
+    @instance.config[:cluster_tag] = "purplish"
+    @instance.config[:base_domain] = "example.com"
+    @instance.config[:hostname]    = 'd999'
+
+    @compute = double
+    @dns = double
+    @zone = double
+    @records = double
+    @record = double
+    @servers = double
+    @server = double
+
+    @server_attribs = {
+        :id => 'i-12345',
+        :flavor_id => 'vanilla',
+        :image_id => 'ami-12345',
+        :availability_zone => 'available',
+        :key_name => 'my_ssh_key',
+        :groups => ['group1', 'group2'],
+        :dns_name => 'dns.name.com',
+        :ip_address => '1.1.1.1',
+        :private_dns_name => 'ip-1-1-1-1.ec2.internal',
+        :private_ip_address => '1.1.1.1',
+        :public_ip_address => '8.8.8.8',
+        :root_device_type => 'instance',
+        :environment => 'development',
+        :hostname => 'd999'
+    }
+
+    @server_attribs.each_pair do |attrib, value|
+      @server.stub(attrib).and_return(value)
+    end
+  end
+
+  describe "run" do
+    before do
+      Fog::Compute::AWS.stub(:new).and_return(@compute)
+      @compute.stub(:servers)
+      @compute.stub(:images).and_return(@images)
+      @zone.stub(:domain).and_return(internal_domain)
+      @instance.stub(:puts)
+      @instance.ui.stub(:error)
+      @instance.stub(:get_user_data)
+      @instance.stub(:ami).and_return(double)
+      Chef::Config[:knife][:hostname] = @server.hostname
+      @instance.stub(:find_ec2).and_return([])
+      @instance.stub(:find_item).and_return([])
+      @instance.stub(:find_r53).and_return([])
+    end
+
+    it "creates an EC2 instance and bootstraps it" do
+      @compute.should_receive(:servers).and_return(@servers)
+      @servers.should_receive(:create).and_return(@server)
+      @instance.run
+    end
+
+    it "waits for aws response and registers host with route 53" do
+      @compute.should_receive(:servers).and_return(@servers)
+      @servers.should_receive(:create).and_return(@server)
+      @instance.config[:wait_for_it] = true
+      @records.should_receive(:create).and_return(true)
+      @zone.should_receive(:records).and_return(@records)
+      @dns.should_receive(:zones).at_least(:once).and_return([@zone])
+      Fog::DNS::AWS.should_receive(:new).and_return(@dns)
+      @server.should_receive(:wait_for).and_return(true)
+      @instance.run
+    end
+
+    describe "#validate!" do
+      context "when there is ec2 host already" do
+        it "should exit with errors" do
+          @instance.should_receive(:find_ec2).and_return([double])
+          @instance.setup_config
+          @instance.config[:environment] = "development"
+          @instance.hostname = 'd999'
+          expect { @instance.validate! }.to raise_error SystemExit
+          @instance.errors.should include "d999 in RSpec::Mocks::Mock already exists. Delete first."
+        end
+      end
+    end
+  end
+end

data/spec/lib/knife-instance/zestknife_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe ZestKnife do
+  subject { described_class.new }
+
+  before do
+    subject.stub(:domain).and_return('internal.com.')
+    subject.class.stub(:AWS_REGIONS).and_return(['some_region'])
+  end
+
+  describe "#fqdn" do
+    it { subject.fqdn('').should == '' }
+    it { subject.fqdn(nil).should == '' }
+    it "provides a valid fqdn" do
+      fqdn = subject.fqdn('d999')
+      fqdn.should == 'd999.internal.com.'
+    end
+  end
+
+  describe "#zone" do
+    let(:our_zone)        { double('our dns zone',   :domain => "internal.com.") }
+    let(:some_other_zone) { double('other dns zone', :domain => "zambocom.net.") }
+
+    before(:each) do
+      aws_double = double
+      Zest::AWS.stub(:new).and_return(aws_double)
+      dns_double = double
+      aws_double.stub(:dns).and_return(dns_double)
+      dns_double.stub(:zones).and_return([our_zone, some_other_zone])
+    end
+
+    its(:zone) { should == our_zone }
+  end
+
+  describe "#domain" do
+    its(:domain) { should match(/[a-z]+\.[a-z]+\./) }
+    it { subject.domain[-1].should == '.' }
+  end
+
+  describe "#errors?" do
+    it "should be true when there are any errors" do
+      subject.errors << "Hello"
+      subject.errors?.should be_true
+    end
+
+    it "should be false when there are no errors" do
+      subject.errors?.should be_false
+    end
+  end
+
+  describe "#setup_config" do
+    after { Chef::Config[:knife].delete :foo }
+
+    it "should find env var and add to Chef::Config" do
+      ENV["FOO"] = "bar"
+      subject.setup_config(['FOO'])
+      Chef::Config[:knife]['FOO'].should == "bar"
+    end
+
+    it "should prefer Chef::Config[:knife] options over ENV options" do
+      ENV["foo"] = "bar"
+      subject.setup_config(["foo"])
+      Chef::Config[:knife]["foo"].should == "bar"
+    end
+  end
+
+  describe "#validate!" do
+    before do
+      subject.ui.stub(:error)
+    end
+
+    it "should add validation errors to error list" do
+      lambda { subject.validate!([:foo]) }.should raise_error SystemExit
+      subject.errors.should have(1).error
+    end
+
+    it "should report existing errors" do
+      subject.errors << "Hello"
+      lambda { subject.validate!([]) }.should raise_error SystemExit
+      subject.errors.should have(1).error
+    end
+  end
+
+  describe "#errors" do
+    it "should not be assignable" do
+      lambda { subject.errors = ['some-new-errors'] }.should raise_error
+    end
+
+    it "should be appendable" do
+      subject.errors.should respond_to :<<
+      subject.errors << "Hello"
+      subject.errors[0].should == "Hello"
+    end
+  end
+
+  describe "#find_r53" do
+    let(:r53_cname_record) do
+      double('Fog::DNS::AWS::Record',
+           :class => 'Fog::DNS::AWS::Record',
+           :name => "d999.internal.com.",
+           :type => "CNAME",
+           :value => "127-1-1-1.compute-1.amazonaws.com")
+    end
+
+    before do
+      Fog::DNS.stub(:new) { double('fog dns client',
+                                 :zones => [double('fake dns zone',
+                                                 :records => r53_records,
+                                                 :domain => "internal.com.")])}
+    end
+
+    context "instance exists" do
+      let(:r53_records) { [r53_cname_record] }
+      it { subject.find_r53('d999').should == [ r53_cname_record ] }
+    end
+
+    context "there is no such instance" do
+      let(:r53_records) { double('Fake records', :select => [], :get => nil) }
+      it { subject.find_r53('d999').should == [] }
+    end
+  end
+
+  describe "#find_ec2" do
+    let(:ec2_servers) { [ec2_instance] }
+    let(:ec2_instance) do
+      double('Fog::Compute::AWS::Server',
+           :class => 'Fog::Compute::AWS::Server',
+           :id => 'my_ec2_instance',
+           :tags => {'Name' => 'd999'})
+    end
+
+    before do
+      Fog::Compute.stub(:new) { double('fog compute client', :servers => ec2_servers) }
+    end
+
+    context "instance exists" do
+      let(:ec2_servers) { [ec2_instance] }
+      it { subject.find_ec2('d999').should == [ ec2_instance ] }
+    end
+
+    context "there is no such instance" do
+      let(:ec2_servers) { [] }
+      it { subject.find_ec2('d999').should == [] }
+    end
+  end
+
+  describe "#find_item" do
+    let(:client) { double }
+
+    context "when class can be loaded" do
+      let(:remote_resource) { double }
+      before { client.should_receive(:load).with('my-name').and_return remote_resource }
+      it { subject.find_item(client, 'my-name').should == [remote_resource] }
+    end
+
+    context "when class cannot be loaded" do
+      let(:exception) { Net::HTTPServerException.new "example.com", 1234 }
+      before { client.should_receive(:load).with('my-name').and_raise exception }
+      it { subject.find_item(client, 'my-name').should == [] }
+    end
+  end
+
+  describe "#generate_hostname" do
+    before { subject.instance_variable_set :@base_domain, 'example.com' }
+
+    it "should generate a valid hostname" do
+      subject.should_receive(:check_services).exactly(2).times.and_return([])
+      subject.validate_hostname subject.generate_hostname("production")
+      subject.errors?.should be_false
+    end
+
+    it "should fail if the hostname is taken" do
+      subject.should_receive(:check_services).exactly(5).times.and_return(["fake_error"])
+      subject.generate_hostname "production"
+      subject.errors?.should be_true
+    end
+  end
+
+  describe "#validate_hostname" do
+    let(:hostname) { 'd123' }
+    before { subject.should_receive(:check_services).and_return(existing_services) }
+
+    context "there is no such a host" do
+      let(:existing_services) { [] }
+
+      it "is valid" do
+        subject.validate_hostname hostname
+        subject.errors?.should be_false
+      end
+    end
+
+    context "when the same host already exists" do
+      let(:existing_services) { [hostname] }
+
+      it "is not valid" do
+        subject.validate_hostname hostname
+        subject.errors?.should be_true
+      end
+    end
+  end
+
+  describe '#random_hostname' do
+    context 'environment is production' do
+      let(:env) { 'production' }
+      before { subject.stub(:base_domain).and_return('example.com') }
+
+      context 'external domain is example.com' do
+        it { subject.random_hostname(env).should =~ /^ep\d\d\d$/ }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path '../lib', File.dirname(__FILE__)
+ENV['aws_access_key_id']     = '12345'
+ENV['aws_secret_access_key'] = '12345'
+ENV['aws_ssh_key']           = 'some_key'
+ENV['DATABAG_KEY_PATH']      = File.expand_path 'support/databag.key', File.dirname(__FILE__)
+
+Bundler.require :default, :development
+require_all 'lib/chef'
+require_all 'lib/knife-instance'
+require 'fog'
+
+Fog.mock!
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Chef::Config[:environment] = nil
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: knife-instance
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Tamoykin
+- Val Brodsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.24
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.24
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manage EC2 instances with Chef from the command line
+email:
+- at@zestfinance.com
+- vlb@zestfinance.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- knife-instance.gemspec
+- lib/chef/knife/instance_create.rb
+- lib/knife-instance.rb
+- lib/knife-instance/aws.rb
+- lib/knife-instance/bootstrap_generator.rb
+- lib/knife-instance/templates/boot.sh.erb
+- lib/knife-instance/version.rb
+- lib/knife-instance/zestknife.rb
+- spec/lib/chef/knife/instance_create_spec.rb
+- spec/lib/knife-instance/zestknife_spec.rb
+- spec/spec_helper.rb
+- spec/support/databag.key
+homepage: https://github.com/ZestFinance/knife-instance
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3631599552630895710
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3631599552630895710
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Manage EC2 instances with Chef from the command line
+test_files:
+- spec/lib/chef/knife/instance_create_spec.rb
+- spec/lib/knife-instance/zestknife_spec.rb
+- spec/spec_helper.rb
+- spec/support/databag.key