vagrant-aws 0.0.1

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

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

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

data/lib/vagrant-aws/box.rb

@@ -0,0 +1,20 @@
+module VagrantAWS
+
+	class Box < Vagrant::Box
+	
+		%w{ ovf_file repackage destroy }.each do |method|
+			undef_method(method)
+		end
+
+		def add
+			raise Vagrant::Errors::BoxAlreadyExists, :name => name if File.directory?(directory)
+			env.actions.run(:aws_add_image, { "box" => self, "validate" => false })
+		end
+
+		def remove(options=nil)
+			env.actions.run(:aws_remove_image, { "box" => self, "validate" => false }.merge(options || {}))
+		end
+
+	end
+
+end

data/lib/vagrant-aws/box_collection.rb

@@ -0,0 +1,15 @@
+module VagrantAWS
+	class BoxCollection < Vagrant::BoxCollection
+
+		def reload!
+			@boxes.clear
+      Dir.open(env.boxes_path) do |dir|
+        dir.each do |d|
+          next if d == "." || d == ".." || !File.directory?(env.boxes_path.join(d))
+          @boxes << VagrantAWS::Box.new(env, d)
+        end
+      end
+		end
+
+	end
+end

data/lib/vagrant-aws/command.rb

@@ -0,0 +1,186 @@
+require 'fog'
+
+module VagrantAWS
+		
+	class AWSCommands < Vagrant::Command::GroupBase		
+		register "aws", "Commands to interact with Amazon AWS (EC2)"
+
+		def initialize(*args)
+			super
+			initialize_aws_environment(*args)
+		end
+
+
+		desc "up [NAME]", "Creates the Vagrant environment on Amazon AWS."
+		method_options :provision => true
+		def up(name=nil)	
+			target_vms(name).each do |vm|				
+				if vm.created?
+					vm.env.ui.info I18n.t("vagrant.commands.up.vm_created")
+				else
+					vm.env.actions.run(:aws_up, "provision.enabled" => options[:provision])
+				end
+			end
+		end
+
+
+		desc "destroy [NAME]", "Destroy the Vagrant AWS environment, terminating the created virtual machines."
+		def destroy(name=nil)
+			target_vms(name).each do |vm|
+				if vm.created?
+					vm.env.actions.run(:aws_destroy)
+				else
+					vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+				end
+			end
+		end
+
+
+		desc "status", "Show the status of the current Vagrant AWS environment." 
+		def status
+			state = nil
+			results = target_vms.collect do |vm|
+				state = vm.created? ? vm.vm.state.to_s : 'not_created'
+				"#{vm.name.to_s.ljust(25)}#{state.gsub("_", " ")}"	
+			end
+			state = target_vms.length == 1 ? state : "listing"
+			@env.ui.info(I18n.t("vagrant.commands.status.output",
+                    :states  => results.join("\n"),
+                    :message => I18n.t("vagrant.plugins.aws.commands.status.#{state}")),
+                    :prefix  => false)
+		end
+
+
+		desc "ssh [NAME]", "SSH into the currently running Vagrant AWS environment."
+		method_options %w( execute -e ) => :string
+		def ssh(name=nil)
+			raise Vagrant::Errors::MultiVMTargetRequired, :command => "ssh" if target_vms.length > 1
+			
+			ssh_vm = target_vms.first
+			ssh_vm.env.actions.run(VagrantAWS::Action::PopulateSSH)
+
+			if options[:execute]
+				ssh_vm.ssh.execute do |ssh|
+          ssh_vm.env.ui.info I18n.t("vagrant.commands.ssh.execute", :command => options[:execute])
+          ssh.exec!(options[:execute]) do |channel, type, data|
+            ssh_vm.env.ui.info "#{data}"
+          end
+        end
+			else
+				raise Vagrant::Errors::VMNotCreatedError if !ssh_vm.created?
+        raise Vagrant::Errors::VMNotRunningError if !ssh_vm.vm.running?
+        ssh_vm.ssh.connect 
+			end	
+		end
+
+
+		desc "provision [NAME]", "Rerun the provisioning scripts on a running VM."
+		def provision(name=nil)
+			target_vms(name).each do |vm|
+				if vm.created? && vm.vm.state == 'running'
+					vm.env.actions.run(:aws_provision)
+				else
+					vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+				end
+      end
+    end
+		
+
+		desc "suspend [NAME]", "Suspend a running Vagrant AWS environment"
+		def suspend(name=nil)
+			target_vms(name).each do |vm|
+				if vm.created?
+					vm.env.actions.run(:aws_suspend)
+				else
+					vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+				end
+			end	
+		end
+
+
+		desc "resume [NAME]", "Resume a suspended Vagrant AWS environment"
+		def resume(name=nil)
+			target_vms(name).each do |vm|
+				if vm.created?
+					vm.env.actions.run(:aws_resume)
+				else
+					vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+				end
+			end	
+		end
+
+
+		desc "ssh_config [NAME]", "outputs .ssh/config valid syntax for connecting to this environment via ssh"
+		method_options %w{ host_name -h } => :string
+		def ssh_config(name=nil)
+			raise Vagrant::Errors::MultiVMTargetRequired, :command => "ssh_config" if target_vms.length > 1
+	
+			ssh_vm = target_vms.first
+			raise Vagrant::Errors::VMNotCreatedError if !ssh_vm.created?
+			ssh_vm.env.actions.run(VagrantAWS::Action::PopulateSSH)
+	
+			$stdout.puts(Vagrant::Util::TemplateRenderer.render("ssh_config", {
+        :host_key => options[:host] || "vagrant",
+        :ssh_host => ssh_vm.env.config.ssh.host,
+				:ssh_user => ssh_vm.env.config.ssh.username,
+				:ssh_port => ssh_vm.ssh.port,
+				:private_key_path => ssh_vm.env.config.ssh.private_key_path
+      }))
+		end
+
+
+		desc "box_create [NAME]", "create image box from running Vagrant AWS VM"
+		method_option :register, :aliases => '-r', :type => :boolean, :default => true, :banner => "register with AWS" 
+		method_option :image_name, :aliases => '-f', :type => :string, :banner => "name of created image"
+		method_option :image_desc, :aliases => '-d', :type => :string, :banner => "description of created image" 
+		def box_create(name=nil)
+			raise Vagrant::Errors::MultiVMTargetRequired, :command => "box_create" if target_vms.length > 1
+			
+			ami_vm = target_vms.first		
+			ami_vm.env.actions.run(:aws_create_image, {
+				'package.output' => options[:image_name] || env.config.package.name,
+				'image.register' => options[:register],
+				'image.name' => options[:image_name] || "vagrantaws_#{rand(36**8).to_s(36)}",
+				'image.desc' => options[:image_desc] || "Image created by vagrant-aws"
+			})
+
+		end
+
+
+		desc "box_add NAME URI", "Add an AWS image box to the system"
+		def box_add(name, uri)
+			Box.add(env, name, uri)
+		end
+
+
+		desc "box_list", "list available AWS image boxes"
+		def box_list
+			boxes = env.boxes.sort
+			return env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false) if boxes.empty?
+			boxes.each { |b| env.ui.info(b.name, :prefix => false) }
+		end
+
+
+		desc "box_remove NAME", "Remove named image box from system and optionally deregister image with AWS"
+		method_option :deregister, :aliases => '-d', :type => :boolean, :default => false, :banner => "deregister with AWS"
+		def box_remove(name)
+			b = env.boxes.find(name)
+      raise Vagrant::Errors::BoxNotFound, :name => name if !b
+      b.remove({ 'image.deregister' => options[:deregister] })
+    end
+			
+		protected
+	
+		# Reinitialize "AWS" environment
+		def initialize_aws_environment(args, options, config)
+			raise Errors::CLIMissingEnvironment if !config[:env]
+			if config[:env].is_a?(VagrantAWS::Environment)
+				@env = config[:env]
+			else
+				@env = VagrantAWS::Environment.new
+				@env.ui = config[:env].ui  # Touch up UI 
+				@env.load!
+			end
+		end
+	end	
+end

data/lib/vagrant-aws/config.rb

@@ -0,0 +1,38 @@
+module VagrantAWS
+	# A configuration class to configure defaults which are used for
+  # the `vagrant-aws` plugin.
+  class Config < Vagrant::Config::Base
+    configures :aws
+   	
+		attr_accessor :key_name
+		attr_writer   :private_key_path
+		attr_accessor :username
+		attr_accessor :security_groups
+
+		attr_accessor :image
+		attr_accessor :flavor
+
+		attr_accessor :region
+		attr_accessor :availability_zone
+
+		def initialize
+			@security_groups   = ["default"]
+			@region            = "us-east-1"
+			@username          = "ubuntu"
+			@image             = "ami-2ec83147"
+			@flavor            = "t1.micro"
+		end
+
+		def using?
+			return top.env.is_a?(VagrantAWS::Environment)
+		end
+
+		def private_key_path
+			@private_key_path.nil? ? nil : File.expand_path(@private_key_path)
+		end
+		
+		def validate(errors)
+			errors.add(I18n.t("vagrant.config.ssh.private_key_missing", :path => private_key_path)) if private_key_path && !File.exists?(private_key_path)
+		end
+	end
+end	

data/lib/vagrant-aws/environment.rb

@@ -0,0 +1,79 @@
+require 'fog'
+
+module VagrantAWS
+	# Represents a single Vagrant environment, overridden to not alias with
+	# existing Vagrant data storage, VM implementation, etc.
+	class Environment < Vagrant::Environment
+		DEFAULT_DOTFILE = ".vagrantaws"
+		FOGFILE         = ".fog"
+
+		def dotfile_path
+			root_path.join(DEFAULT_DOTFILE) rescue nil
+		end
+	
+		def aws_home_path
+      home_path.join("aws")
+    end
+	
+		def boxes_path
+			aws_home_path.join("images")
+		end
+	
+		def boxes
+      return parent.boxes if parent
+      @_boxes ||= VagrantAWS::BoxCollection.new(self)
+    end
+
+		def ssh_keys_path
+			aws_home_path.join("keys")
+		end
+
+		def ssh_keys
+			return parent.ssh_keys if parent
+			Dir.chdir(ssh_keys_path) { |unused| Dir.entries('.').select { |f| File.file?(f) } }
+		end
+
+		def load!
+			super
+			
+			# Setup fog credential path
+			project_fog_path = root_path.join(FOGFILE) rescue nil
+			Fog.credentials_path = File.expand_path(fogfile_path) if project_fog_path && File.exist?(project_fog_path)
+
+			self
+		end
+
+		# Override to create "AWS" specific directories in 'home_dir'
+		def load_home_directory!
+			super
+
+			dirs = %w{ images keys }.map { |d| aws_home_path.join(d) }
+			dirs.each do |dir|
+				next if File.directory?(dir)
+				ui.info I18n.t("vagrant.general.creating_home_dir", :directory => dir)
+        FileUtils.mkdir_p(dir)
+      end	
+		end
+
+		# Override to create "AWS" VM
+		def load_vms!
+			result = {}
+
+			# Load the VM UUIDs from the local data store
+			(local_data[:active] || {}).each do |name, desc|
+				result[name.to_sym] = VagrantAWS::VM.find(desc, self, name.to_sym)
+			end
+
+			# For any VMs which aren't created, create a blank VM instance for
+			# them
+			all_keys = config.vm.defined_vm_keys
+			all_keys = [DEFAULT_VM] if all_keys.empty?
+			all_keys.each do |name|
+				result[name] = VagrantAWS::VM.new(:name => name, :env => self) if !result.has_key?(name)
+			end
+
+			result
+		end
+			
+	end
+end

data/lib/vagrant-aws/errors.rb

@@ -0,0 +1,29 @@
+module VagrantAWS
+	module Errors
+
+		class VagrantError < Vagrant::Errors::VagrantError
+			def error_namespace; "vagrant.plugins.aws.errors"; end
+		end
+
+		class NotYetSupported < VagrantError
+			error_key(:not_yet_supported)
+		end
+
+		class KeyNameNotSpecified < VagrantError
+			error_key(:key_name_not_specified)
+		end
+
+		class PrivateKeyFileNotSpecified < VagrantError
+			error_key(:private_key_file_not_specified)
+		end
+
+		class EBSDeviceRequired < VagrantError
+			error_key(:ebs_device_required)
+		end
+
+		class VMCreateFailure < VagrantError
+			error_key(:vm_create_failure)
+		end
+
+	end
+end

data/lib/vagrant-aws/middleware.rb

@@ -0,0 +1,53 @@
+require 'vagrant-aws/action/create'
+require 'vagrant-aws/action/terminate'
+require 'vagrant-aws/action/create_sshkey'
+require 'vagrant-aws/action/populate_ssh'
+require 'vagrant-aws/action/prepare_provisioners'
+require 'vagrant-aws/action/suspend'
+require 'vagrant-aws/action/resume'
+require 'vagrant-aws/action/create_image'
+require 'vagrant-aws/action/deregister_image'
+
+module VagrantAWS
+
+	Vagrant::Action.register(:aws_provision, Vagrant::Action::Builder.new do
+		use Action::PopulateSSH
+		use Action::PrepareProvisioners
+		use Vagrant::Action[:provision]
+	end)
+
+	Vagrant::Action.register(:aws_up, Vagrant::Action::Builder.new do
+		use Action::CreateSSHKey
+		use Action::Create
+		use Vagrant::Action[:aws_provision]
+	end)
+
+	Vagrant::Action.register(:aws_destroy, Vagrant::Action::Builder.new do
+		use Action::Terminate
+	end)
+
+	Vagrant::Action.register(:aws_suspend, Vagrant::Action::Builder.new do
+		use Action::Suspend
+	end)
+
+	Vagrant::Action.register(:aws_resume, Vagrant::Action::Builder.new do
+		use Action::Resume
+	end)
+
+	Vagrant::Action.register(:aws_create_image, Vagrant::Action::Builder.new do
+		use Action::CreateImage
+		use Vagrant::Action::VM::Package
+	end)
+
+	Vagrant::Action.register(:aws_add_image, Vagrant::Action::Builder.new do
+		use Vagrant::Action::Box::Download
+    use Vagrant::Action::Box::Unpackage
+	end)
+
+	Vagrant::Action.register(:aws_remove_image, Vagrant::Action::Builder.new do
+		use Action::DeregisterImage
+    use Vagrant::Action::Box::Destroy
+	end)
+
+
+end