vagrant-aws 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in vagrant-aws.gemspec
+gemspec

data/README.md

@@ -0,0 +1,65 @@
+# 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>
+
+If you already have an Amazon key pair (created when you signed-up, or
+someother time), you can specify the key name and the path the associated
+private key. Alternately, if no key name is specified, `vagrant-aws` will
+automatically create and register a key pair for you with the name
+`vagrant_<MAC ADDRESS>`. If you want to use your pre-existing key, you can
+specify the key name and path 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 and Image Boxes
+
+`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
+
+Alternately you can work with "image boxes" using the `vagrant aws box_*` commands. These are 
+similar to Vagrant's native boxes, and have a similar API, but wrap AWS ami IDs. The major 
+difference is that box creation and removal can optionally reregister and deregister AMIs
+with AWS. Note that AMI creation is only supported for EBS-backed instances.
+
+## 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.	

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+end
+

data/lib/vagrant-aws.rb

@@ -0,0 +1,14 @@
+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'
+require 'vagrant-aws/box'
+require 'vagrant-aws/box_collection'
+
+# Add our custom translations to the load path
+I18n.load_path << File.expand_path("../../locales/en.yml", __FILE__)

data/lib/vagrant-aws/action/create.rb

@@ -0,0 +1,56 @@
+module VagrantAWS
+	class Action
+		class Create
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				raise Errors::KeyNameNotSpecified if env["config"].aws.key_name.nil?
+				
+				env.ui.info I18n.t("vagrant.plugins.aws.actions.create.creating")
+
+				server_def = server_definition(env["config"])
+
+				# Verify AMI is valid (and in the future enable options specific to EBS-based AMIs)
+				image = env["vm"].connection.images.get(server_def[:image_id])
+				image.wait_for { state == 'available' }
+
+				env["vm"].vm = env["vm"].connection.servers.create(server_def)
+				raise VagrantAWS::Errors::VMCreateFailure if env["vm"].vm.nil? || env["vm"].vm.id.nil?
+				
+				env.ui.info I18n.t("vagrant.plugins.aws.actions.create.created", :id => env["vm"].vm.id)
+								
+				env["vm"].vm.wait_for { ready? }
+				env["vm"].connection.create_tags(env["vm"].vm.id, { "name" => env["vm"].name })
+
+				env.ui.info I18n.t("vagrant.plugins.aws.actions.create.available", :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
+

data/lib/vagrant-aws/action/create_image.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+# Path vagrant to not delete pre-existing package file (pull request submitted upstream)
+
+module Vagrant
+  class Action
+    module General
+      
+			class Package
+				def recover(env)
+          unless env["vagrant.error"].is_a?(Errors::PackageOutputExists)
+						# Cleanup any packaged files if the packaging failed at some point.
+						File.delete(tar_path) if File.exist?(tar_path)
+					end
+        end
+			end
+
+		end
+	end
+end
+
+module VagrantAWS
+	class Action
+		class CreateImage
+			include Vagrant::Util
+
+			PACKAGE_VAGRANTFILE = <<EOT
+Vagrant::Config.run do |config|
+  # This Vagrantfile is auto-generated by `vagrant aws create_image` to contain
+  # the image id and region. Custom configuration should be placed in
+  # the actual `Vagrantfile` in this box.
+  config.vm.base_mac = "000000000000"  # Unneeded
+	config.aws.image = "<%= image %>"
+	config.aws.region = "<%= region %>"
+end
+EOT
+
+			attr_reader :temp_dir, :image
+
+			def initialize(app, env)
+				@app = app
+				@env = env
+			end
+
+			def call(env)
+				@env = env
+
+				raise Vagrant::Errors::VMNotCreatedError if !@env["vm"].created?
+				raise Vagrant::Errors::VMNotRunningError if !@env["vm"].vm.running?
+				raise VagrantAWS::Errors::EBSDeviceRequired, :command => "box_create" if @env["image.register"] and @env["vm"].vm.root_device_type != "ebs"
+			
+				if @env["image.register"]
+					@env.ui.info I18n.t("vagrant.plugins.aws.actions.create_image.creating")
+					@image = @env["vm"].connection.create_image(@env["vm"].vm.id, @env['image.name'], @env['image.desc'])
+					@image = @env["vm"].connection.images.new({ :id => @image.body['imageId'] })
+					@image.wait_for { state == "available" }
+				else
+					@image = @env["vm"].connection.images.get(@env["vm"].vm.image_id)
+				end
+
+				setup_temp_dir
+				export
+
+				@app.call(@env)
+				
+				cleanup_temp_dir
+			end
+
+			def recover(env)
+				if env["image.register"]
+					env.ui.info I18n.t("vagrant.plugins.aws.actions.deregister_image.deregistering", :image => @image.id)
+					@image.deregister(!@image.root_device_name.nil?)  # Don't try to delete backing snapshot if it was not created
+				end
+				cleanup_temp_dir
+			end
+		
+			def cleanup_temp_dir
+				if temp_dir && File.exist?(temp_dir)
+					FileUtils.rm_rf(temp_dir)
+				end
+			end
+
+			def setup_temp_dir
+				@env.ui.info I18n.t("vagrant.actions.vm.export.create_dir")
+				@temp_dir = @env["export.temp_dir"] = @env.env.tmp_path.join(Time.now.to_i.to_s)
+				FileUtils.mkpath(@env["export.temp_dir"])
+			end
+		
+			# Write a Vagrantfile with the relevant information
+			def export
+				File.open(File.join(@env["export.temp_dir"], 'Vagrantfile'), "w") do |f|
+					f.write(TemplateRenderer.render_string(PACKAGE_VAGRANTFILE, {
+						:image => @image.id,
+						:region => @env["config"].aws.region
+					}))
+				end
+				File.open(File.join(@env["export.temp_dir"], 'image.json'), "w") do |f|
+					f.write(@image.to_json)
+				end
+			end
+
+
+		end
+	end
+end
+

data/lib/vagrant-aws/action/create_sshkey.rb

@@ -0,0 +1,39 @@
+require 'Macaddr'
+
+module VagrantAWS
+	class Action
+		class CreateSSHKey
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				@env = env
+				
+				if @env["config"].aws.key_name.nil?	
+          # Do we have a previously created key available on AWS?
+					key = @env["vm"].connection.key_pairs.all('key-name' => @env.env.ssh_keys).first
+					if key.nil?
+						# Create and save key
+						key = @env["vm"].connection.key_pairs.create(:name => "vagrantaws_#{Mac.addr.gsub(':','')}")
+						env.ui.info I18n.t("vagrant.plugins.aws.actions.create_ssh_key.created", :name => key.name)	
+						File.open(local_key_path(key.name), File::WRONLY|File::TRUNC|File::CREAT, 0600) { |f| f.write(key.private_key) }	
+					end
+					
+					@env["config"].aws.key_name = key.name
+					@env["config"].aws.private_key_path = local_key_path(key.name) 
+				end
+
+				@app.call(env)
+			end
+
+			def local_key_path(name)
+				@env.env.ssh_keys_path.join(name)
+			end
+
+		end
+	end
+end
+
+
+

data/lib/vagrant-aws/action/deregister_image.rb

@@ -0,0 +1,27 @@
+module VagrantAWS
+	class Action
+		class DeregisterImage
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				if env['image.deregister']
+					image = Fog::Compute.new(:provider => 'AWS').images.new(load_image(env))	
+					env.ui.info I18n.t("vagrant.plugins.aws.actions.deregister_image.deregistering", :image => image.id)
+					image.reload
+					image.deregister(true)  # Delete snapshot when deregistering	
+				end
+				@app.call(env)
+			end
+
+			def load_image(env)
+				File.open(File.join(env["box"].directory, "image.json"), "r") do |f|
+					JSON.parse(f.read)
+				end
+			end
+
+		end
+	end
+end
+

data/lib/vagrant-aws/action/populate_ssh.rb

@@ -0,0 +1,41 @@
+module VagrantAWS
+	class Action
+		class PopulateSSH
+			def initialize(app, env)
+				@app = app
+			end
+
+			def call(env)
+				@env = env
+
+				if @env["config"].aws.private_key_path.nil?
+					# See if we are using a key vagrant aws generated
+					@env["config"].aws.private_key_path = local_key_path(env["vm"].vm.key_name) if env["vm"].vm.key_name =~ /^vagrantaws_[0-9a-f]{12}/
+				end
+				
+				raise VagrantAWS::Errors::PrivateKeyFileNotSpecified if env["config"].aws.private_key_path.nil? || !File.exists?(env["config"].aws.private_key_path)
+
+				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
+	
+			def local_key_path(name)
+				@env.env.ssh_keys_path.join(name)
+			end
+
+		end
+	end
+end
+
+

data/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