Fill out basic complement of AWS commands, including chef-solo

provisioning, using middleware based implementation.

Author: mlinderm

.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rvmrc

README.md

@@ -0,0 +1,57 @@
+# vagrant-aws
+
+`vagrant-aws` is a plugin for [Vagrant](http://vagrantup.com) which allows the user
+to instantiate the Vagrant environment on Amazon AWS (using EC2). This document assumes
+you are familiar with Vagrant, if not, the project has excellent [documentation](http://vagrantup.com/docs/index.html).
+
+**NOTE:** This plugin is "pre-alpha", see below for the caveats
+
+## Installing / Getting Started
+
+To use this plugin, first install Vagrant, then install the plugin gem. It should be
+picked up automatically by vagrant. You can then use the `vagrant aws` commands.
+
+`vagrant-aws` uses [fog](https://github.com/geemus/fog) internally, and you will need to
+specify your Amazon AWS credentials in a "fog" file. Create `~/.fog` with:
+
+	---
+	default: 
+		aws_access_key_id:  <YOUR ACCESS KEY>
+		aws_secret_access_key: <YOUR SECRET KEY>
+
+Additionally, although `vagrant-aws` has many useful defaults, you will need to specify your
+Amazon AWS key name and the path the associated private key. You can specify this on a
+per-environment basis (i.e., in each Vagrantfile) or in a single Vagrantfile in your
+`~/.vagrant` directory. In the latter case, create `~/.vagrant/Vagrantfile` with:
+
+	Vagrant::Config.run do |config|
+		config.aws.key_name = "<KEY NAME>"
+		config.aws.private_key_path = "<PATH/TO/KEY>"
+	end
+	
+With the above in place you should be ready instantiate your Vagrant environment on 
+Amazon AWS. See below for additional information on configuration, caveats, etc..
+
+## Configuration
+
+`vagrant-aws` defines a new configuration class for use in your Vagrantfile. An example
+usage (showing the defaults) would be:
+
+	Vagrant::Config.run do |config|
+		config.aws.region = "us-east-1"
+		config.aws.availability_zone = nil  # Let AWS choose
+		config.aws.image = "ami-2ec83147"   # EBS-backed Ubuntu 10.04 64-bit
+		config.aws.username = "ubuntu"
+		config.aws.security_groups = ["default"]
+		config.aws.flavor = "t1.micro"
+	end
+
+## Caveats
+
+`vagrant-aws` is "pre-alpha" and currently only supports creation, suspension, resumption
+and descruction of the Vagrant environment. Provisioning should be supported for shell,
+chef-server and chef-solo, but has only been tested with chef-solo and on an Ubuntu guest. 
+Only a subset of Vagrant features are supported. Currently port forwarding and shared 
+directories are not implemented, nor is host networking (although that is less relevant for AWS). 
+`vagrant-aws` in general has only been tested for a single VM, on OSX 10.6, with chef-solo.
+	

lib/vagrant-aws.rb

@@ -1,4 +1,12 @@
 require 'vagrant'
 require 'vagrant-aws/version'
+require 'vagrant-aws/errors'
+require 'vagrant-aws/environment'
+require 'vagrant-aws/vm'
 require 'vagrant-aws/config'
+require 'vagrant-aws/middleware'
 require 'vagrant-aws/command'
+require 'vagrant-aws/system'
+
+# Add our custom translations to the load path
+I18n.load_path << File.expand_path("../../locales/en.yml", __FILE__)

lib/vagrant-aws/action/create.rb

@@ -0,0 +1,53 @@
+module VagrantAWS
+	class Action
+		class Create
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				env.ui.info "Creating VM ..."
+
+				server_def = server_definition(env["config"])
+
+				# Verify AMI is valid (and in the future enable options specific to EBS-based AMIs)
+				ami = env["vm"].connection.images.get(server_def[:image_id])
+
+				env["vm"].vm = env["vm"].connection.servers.create(server_def)
+
+				env.ui.info("Created EC2 Server: #{env["vm"].vm.id}")
+				env.ui.info("Waiting for server to become ready... (this may take a few minutes)")
+				
+				env["vm"].vm.wait_for { ready? }
+				env["vm"].connection.create_tags(env["vm"].vm.id, { "name" => env["vm"].name })
+
+				env.ui.info("Server available at DNS: #{env["vm"].vm.dns_name}")
+
+				@app.call(env)
+			end
+
+			def recover(env)
+				if env["vm"].created?
+					return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+					# Interrupted, destroy the VM
+					env["actions"].run(:aws_destroy)
+				end
+			end
+
+			def server_definition(config)
+				{
+					:image_id  => config.aws.image,
+					:groups    => config.aws.security_groups,
+					:flavor_id => config.aws.flavor,
+					:key_name  => config.aws.key_name,
+					:username  => config.aws.username,
+					:private_key_path  => config.aws.private_key_path,
+					:availability_zone => config.aws.availability_zone
+				}
+			end
+
+		end
+	end
+end
+

lib/vagrant-aws/action/populate_ssh.rb

@@ -0,0 +1,30 @@
+module VagrantAWS
+	class Action
+		class PopulateSSH
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				raise VagrantAWS::Errors::PrivateKeyFileNotSpecified if env["config"].aws.private_key_path.nil?
+
+				env["config"].ssh.host             = env["vm"].vm.dns_name
+				env["config"].ssh.username         = env["config"].aws.username
+				env["config"].ssh.private_key_path = env["config"].aws.private_key_path
+				env["config"].ssh.port             = 22
+
+				# Make sure we can connect
+				begin
+					env["vm"].vm.wait_for { env["vm"].ssh.up? }
+				rescue Fog::Errors::Error
+					raise Vagrant::Errors::SSHConnectionRefused
+				end
+
+				@app.call(env)
+			end
+	
+		end
+	end
+end
+
+

lib/vagrant-aws/action/prepare_provisioners.rb

@@ -0,0 +1,127 @@
+require 'archive/tar/minitar'
+
+module VagrantAWS
+	class Action
+		class PrepareProvisioners
+			def initialize(app, env)
+				@app = app
+				@env = env
+				@env["provision.enabled"] = true if !@env.has_key?("provision.enabled")
+				@provisioner_configs = []
+
+				load_provisioner_configs if provisioning_enabled?
+			end
+
+			def call(env)
+				@provisioner_configs.each do |provisioner_config|
+					if provisioner_config.is_a?(Vagrant::Provisioners::ChefSolo::Config)
+						env.ui.info I18n.t("vagrant.plugins.aws.actions.prepare_provisioners.uploading_chef_resources")
+						ChefSolo.prepare(provisioner_config)
+					end
+				end
+				@app.call(env)
+			end
+	
+			def provisioning_enabled?
+        !@env["config"].vm.provisioners.empty? && @env["provision.enabled"]
+      end
+
+			def load_provisioner_configs
+				@env["config"].vm.provisioners.each do |provisioner|
+					@provisioner_configs << provisioner.config
+				end
+			end
+		
+			class ChefSolo
+				
+				def self.prepare(config)
+					my_preparer = new(config)
+					my_preparer.bootstrap_if_needed
+					my_preparer.chown_provisioning_folder
+					my_preparer.copy_and_update_paths	
+				end
+
+				def initialize(config)
+					@config = config
+				end
+
+				def bootstrap_if_needed
+					begin
+						@config.env.vm.ssh.execute do |ssh|
+							ssh.sudo!("which chef-solo")
+						end
+					rescue Vagrant::Errors::VagrantError 
+						# Bootstrap chef-solo
+						@config.env.ui.info I18n.t("vagrant.plugins.aws.actions.prepare_provisioners.chef_not_detected", :binary => "chef-solo")
+						@config.env.vm.system.bootstrap_chef
+					end
+				end
+
+
+				def chown_provisioning_folder
+					@config.env.vm.ssh.execute do |ssh|
+						ssh.sudo!("mkdir -p #{@config.provisioning_path}")
+						ssh.sudo!("chown #{@config.env.config.ssh.username} #{@config.provisioning_path}")
+					end
+				end
+
+				def copy_and_update_paths
+					# Copy relevant host paths to remote instance and update provisioner config
+					# to point to new "vm" paths for cookbooks, etc.
+					%w{ cookbooks_path roles_path data_bags_path }.each do |path|
+						copy_host_paths(@config.send(path), path)
+						@config.send "#{path}=", strip_host_paths(@config.send(path)).push([:vm, path])
+					end
+				end
+			
+				def copy_host_paths(paths, target_directory)
+					archive  = tar_host_folder_paths(paths)
+					
+					target_d = "#{@config.provisioning_path}/#{target_directory}"
+					target_f = target_d + '.tar'
+					
+					@config.env.vm.ssh.upload!(archive.path, target_f)
+					@config.env.vm.ssh.execute do |ssh|
+						ssh.sudo!([
+							"mkdir -p #{target_d}",
+							"chown #{@config.env.config.ssh.username} #{target_d}",
+							"tar -C #{target_d} -xf #{target_f}"
+						])
+					end
+
+					target_directory
+				end
+					
+				def tar_host_folder_paths(paths)
+					tarf = Tempfile.new(['vagrant-chef-solo','.tar']) 
+					Archive::Tar::Minitar::Output.open(tarf) do |outp|
+						host_folder_paths(paths).each do |full_path|
+							Dir.chdir(full_path) do |ignored| 
+								Dir.glob("**#{File::SEPARATOR}**") { |entry| Archive::Tar::Minitar.pack_file(entry, outp) }
+							end
+						end
+					end
+					tarf
+				end
+
+
+				def host_folder_paths(paths)
+					paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+					paths.inject([]) do |acc, path|
+						path = [:host, path] if !path.is_a?(Array)
+						type, path = path
+						acc << File.expand_path(path, @config.env.root_path) if type == :host
+						acc
+					end
+				end
+		
+				def strip_host_paths(paths)
+					paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+					paths.delete_if { |path| !path.is_a?(Array) || path[0] == :host }
+				end
+			end
+
+		
+		end
+	end
+end

lib/vagrant-aws/action/resume.rb

@@ -0,0 +1,20 @@
+module VagrantAWS
+	class Action
+		class Resume
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				if env["vm"].vm.state == "stopped"
+					raise VagrantAWS::Errors::EBSDeviceRequired, :command => "resume" if env["vm"].vm.root_device_type != "ebs"
+					env.ui.info I18n.t("vagrant.actions.vm.resume.resuming")
+					env["vm"].vm.start
+				end
+				
+				@app.call(env)
+			end
+	
+		end
+	end
+end

lib/vagrant-aws/action/suspend.rb

@@ -0,0 +1,20 @@
+module VagrantAWS
+	class Action
+		class Suspend
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				if env["vm"].vm.running?
+					raise VagrantAWS::Errors::EBSDeviceRequired, :command => "suspend" if env["vm"].vm.root_device_type != "ebs"
+					env.ui.info I18n.t("vagrant.actions.vm.suspend.suspending")
+          env["vm"].vm.stop
+        end
+				
+				@app.call(env)
+			end
+	
+		end
+	end
+end

lib/vagrant-aws/action/terminate.rb

@@ -0,0 +1,21 @@
+module VagrantAWS
+	class Action
+		class Terminate
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				env.ui.info I18n.t("vagrant.actions.vm.destroy.destroying")
+
+				env["vm"].vm.destroy
+				env["vm"].vm = nil
+
+				@app.call(env)
+			end
+	
+		end
+	end
+end
+
+