vagrant-aws 0.0.1 → 0.1.0

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

@@ -1,56 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

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

@@ -1,20 +0,0 @@
-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

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

@@ -1,20 +0,0 @@
-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