vagrant-aws 0.0.1

data/lib/vagrant-aws/system.rb

@@ -0,0 +1,24 @@
+module Vagrant
+	module Systems
+		class Debian < Linux
+			def bootstrap_chef
+        vm.ssh.execute do |ssh|
+          commands = [
+						"apt-get -y --force-yes update",
+						"apt-get -y --force-yes install ruby ruby-dev libopenssl-ruby irb build-essential wget ssl-cert",
+						"cd /tmp && wget -nv http://production.cf.rubygems.org/rubygems/rubygems-1.7.2.tgz && tar zxf rubygems-1.7.2.tgz",
+						"cd rubygems-1.7.2 && ruby setup.rb --no-format-executable",
+						"gem install chef --no-ri --no-rdoc"
+					]	
+					ssh.sudo!(commands) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              vm.env.ui.info("#{data}: #{type}")
+            end
+          end
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-aws/version.rb

@@ -0,0 +1,3 @@
+module VagrantAWS
+  VERSION = "0.0.1"
+end

data/lib/vagrant-aws/vm.rb

@@ -0,0 +1,94 @@
+require 'fog'
+
+# Patch required by Vagrant::System
+module Fog
+	module Compute
+		class AWS
+			class Server < Fog::Model
+				def running?
+					state == "running"
+				end
+			end
+		end
+	end
+end
+
+
+module VagrantAWS
+		
+	class VM < Vagrant::VM
+
+		[:uuid, :package].each do |method|
+			undef_method(method)
+		end
+
+		class << self
+			def find(desc, env=nil, name=nil)
+				env.ui.info I18n.t("vagrant.plugins.aws.general.getting_status") if env
+				
+				vm = Fog::Compute.new(:provider => 'AWS', :region => desc['region']).servers.get(desc['id'])
+				my_vm = new(:vm => vm, :env => env, :name => name)
+		
+				# Recover key configuration values from data store not available from AWS directly
+				unless my_vm.env.nil?
+					my_vm.env.config.aws.region = desc['region']
+				end
+				
+				my_vm
+      end
+    end
+				
+		# Copied from Vagrant VM, but modified to generate a VagrantAWS::Environment
+		def initialize(opts=nil)
+      defaults = { :vm => nil, :env => nil, :name => nil }
+
+      opts = defaults.merge(opts || {})
+
+      @vm = opts[:vm]
+      @connection = @vm.connection if @vm  # Initialize connection from intialized server
+			
+			@name = opts[:name]
+
+      if !opts[:env].nil?
+        # We have an environment, so we create a new child environment
+        # specifically for this VM. This step will load any custom
+        # config and such.
+        @env = VagrantAWS::Environment.new({
+          :cwd => opts[:env].cwd,
+          :parent => opts[:env],
+          :vm => self
+        }).load!
+
+        # Load the associated system.
+        load_system!
+      end
+
+      @loaded_system_distro = false
+    end
+	
+		def vm=(value)
+      @vm = value
+      env.local_data[:active] ||= {}
+
+      if value && value.id
+        env.local_data[:active][name.to_s] = {
+					'id'     => value.id,
+					'region' => value.connection.instance_variable_get(:@region)
+				}
+      else
+        env.local_data[:active].delete(name.to_s)
+      end
+
+      # Commit the local data so that the next time vagrant is initialized,
+      # it realizes the VM exists
+      env.local_data.commit
+    end
+	
+		def connection(region = nil)
+			@connection ||= Fog::Compute.new(
+				:provider => 'AWS',
+				:region   => region || env.config.aws.region || nil
+			)
+		end
+	end
+end

data/lib/vagrant_init.rb

@@ -0,0 +1,4 @@
+# This file is automatically loaded by Vagrant to load any
+# plugins. This file kicks off this plugin.
+
+require 'vagrant-aws'

data/locales/en.yml

@@ -0,0 +1,64 @@
+en:
+  vagrant:
+    plugins:
+      aws:
+        general:
+          getting_status: "Getting latest environment status..." 
+        errors:
+          not_yet_supported: This feature is not yet supported in Vagrant AWS.      
+          key_name_not_specified: An AWS key name was not specified. Set `aws.key_name` in Vagrantfile. 
+          private_key_file_not_specified: |-
+            Private key file was not specified. Set `aws.private_key_file` to
+            point to key file associated with the specified AWS key name.
+          ebs_device_required: |-
+            %{command} requires an EBS-backed instance. Please Amazon AWS documentation for
+            more information about EBS vs. instance store backed instances.
+          vm_create_failure: VM creation failed.
+        commands:
+          status:
+            running: |-
+              The VM is running. To stop this VM, you can run `vagrant aws suspend` to
+              stop but not destroy this VM (you only pay for the backing EBS volume,
+              not the hourly EC2 server cost) or `vagrant aws destroy` to destroy
+              the VM entirely.
+            stopping: |-
+              The VM is in the process of stopping (suspending). To resume this VM
+              after it has completely stopped, simply run `vagrant aws resume`.
+            stopped: To resume this VM, simply run `vagrant resume`.
+            pending: The VM is in the process of resuming.
+            not_created: |-
+              The environment has not yet been created. Run `vagrant aws resume` to
+              create the environment.
+            listing: |-
+              This environment represents multiple VMs. The VMs are all listed
+              above with their current state. For more information about a specific
+              VM, run `vagrant aws status NAME`.
+        actions:
+          create:
+            creating: "Creating VM ..."
+            created: |-
+              Created EC2 server %{id}. Waiting for server to become ready 
+              (this may take a few minutes).
+            available: |-
+              Server available at %{dns}. 
+              Waiting for SSH to become available. When ready run `vagrant aws ssh_config`
+              for more detailed connection information.
+          prepare_provisioners:
+            chef_not_detected: |-
+              %{binary} not detected. Bootstrapping %{binary} installation. This may
+              take a few minutes.
+            uploading_chef_resources: Uploading chef resources to VM.
+          create_image:
+            creating: |- 
+              Creating AWS AMI. This make take a few minutes. The VM will not be available 
+              during this period.
+          deregister_image:
+            deregistering:
+              Deregistering image %{image} with AWS.
+          create_ssh_key:
+            created: |-
+              No key pairs specified. Created AWS key pair named %{name}.
+
+
+              
+            

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'contest'
+require 'mocha'
+require 'vagrant-aws'
+
+Fog.mock!
+
+module Vagrant
+	module TestHelpers
+
+		# Creates and _loads_ a Vagrant environment at the given path.
+    # If no path is given, then a default {#vagrantfile} is used.
+    def vagrant_env(*args)
+      path = args.shift if Pathname === args.first
+      path ||= vagrantfile
+      VagrantAWS::Environment.new(:cwd => path).load!
+    end
+		
+	end
+end
+
+class Test::Unit::TestCase
+  include Vagrant::TestHelpers
+end

data/test/vagrant-aws/action/create_image_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class CreateImageTest < Test::Unit::TestCase
+	
+	setup do
+		@app, @env = action_env
+		
+		@env.env.vm = VagrantAWS::VM.new(:env => @env.env, :name => "default")
+		@middleware = VagrantAWS::Action::CreateImage.new(@app, @env)
+		
+		@env["vm"].expects(:created?).returns(true)
+		
+		@env["vm"].vm = @env["vm"].connection.servers.create
+		@env["vm"].vm.root_device_type = "ebs"  # Fog mock instances are "instance-store" by default
+		
+		@env["vm"].connection.data[:images] = { "notused" => { "imageId" => @env["vm"].vm.image_id }}
+	end
+
+	should "return error if instance not running" do
+		@env["vm"].vm.stubs(:running?).returns(false)
+		assert_raise(Vagrant::Errors::VMNotRunningError) do
+			@middleware.call(@env)
+		end
+	end
+
+	context "instance running" do
+		setup do
+			@env["vm"].vm.stubs(:running?).returns(true)
+		end
+	
+		should "not create image unless register specified" do
+			@env["vm"].connection.expects(:create_image).never
+			@middleware.call(@env)
+		end
+
+		should "create image if register specified" do
+			@env["vm"].connection.expects(:create_image => @env["vm"].connection.create_image(@env["vm"].vm.id, "test", "test"))
+			@env["image.register"] = true
+			@middleware.call(@env)
+		end
+
+		context "recovery" do
+			setup do
+				@internal_image = @env["vm"].connection.create_image(@env["vm"].vm.id, "test", "test")
+				@env["vm"].connection.stubs(:create_image).returns(@internal_image)
+			end
+
+			should "deregister if error during registration" do
+				@env["image.register"] = true
+				@middleware.call(@env)
+				@middleware.image.expects(:deregister).with(true)
+				@middleware.recover(@env)
+			end
+
+		end
+
+		should "call the next app" do
+			@app.expects(:call).once
+			@middleware.call(@env)
+		end
+	end
+
+end

data/test/vagrant-aws/action/create_ssh_key_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class CreateSSHKeyActionTest < Test::Unit::TestCase
+	setup do
+		@app, @env = action_env
+	
+		@env.env.vm = VagrantAWS::VM.new(:env => @env.env, :name => "default")
+		@connection =  @env["vm"].connection  # We need to trigger the connection creation to load FOG models
+
+		@middleware = VagrantAWS::Action::CreateSSHKey.new(@app, @env)
+		
+		@env["config"].aws.key_name = "default"
+	end
+
+	should "call the next app" do
+    @app.expects(:call).once
+    @middleware.call(@env)
+  end
+
+	should "not do anything if key name is provided" do
+		@env["vm"].connection.expects(:key_pairs).never
+		@middleware.call(@env)
+	end
+
+	context "no key specified" do 
+		setup do
+			@env["config"].aws.key_name = nil
+		end
+	
+		should "use pre-existing key pair if available" do
+			@env.env.expects(:ssh_keys).returns(["existing_key"])
+			@connection.data[:key_pairs] = { "notused" => { "keyName" => "existing_key"} }
+			@middleware.call(@env)
+		end
+
+		should "create key pair if none available" do
+			@env.env.expects(:ssh_keys).returns([])
+			File.stubs(:open).with(@env.env.ssh_keys_path.join("vagrantaws_#{Mac.addr.gsub(':','')}"), File::WRONLY|File::TRUNC|File::CREAT, 0600).returns(nil)  
+			@middleware.call(@env)
+		end
+	end
+
+end

data/test/vagrant-aws/action/create_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class CreateActionTest < Test::Unit::TestCase
+  setup do
+    @app, @env = action_env
+
+		@env.env.vm = VagrantAWS::VM.new(:env => @env.env, :name => "default") 
+		@connection =  @env["vm"].connection  # We need to trigger the connection creation to load FOG models
+
+		@middleware = VagrantAWS::Action::Create.new(@app, @env)
+
+		# Setup FOG mocks
+		@env["config"].aws.key_name = "default"
+		@connection.data[:key_pairs] = { "notused" => { "keyName" => "default"} }
+		@connection.data[:images] = { "default" => { "imageId" => @env["config"].aws.image, "imageState" => 'available' } }
+	end
+
+	should "call the next app" do
+    @app.expects(:call).once
+    @middleware.call(@env)
+  end
+
+  should "create running AWS server" do
+    @middleware.call(@env)
+		
+		assert_not_nil @env["vm"].vm
+		assert_instance_of Fog::Compute::AWS::Server, @env["vm"].vm
+		assert @env["vm"].vm.running?
+	end
+
+
+	should "mark environment erroneous and not continue chain on failure" do
+    Fog::Compute::AWS::Servers.any_instance.stubs(:create).returns(nil)
+		@app.expects(:call).never
+    assert_raises(VagrantAWS::Errors::VMCreateFailure) {
+      @middleware.call(@env)
+    }
+  end
+
+  context "recovery" do
+    setup do
+      @env["vm"].stubs(:created?).returns(true)
+    end
+
+    should "not run the destroy action on recover if error is a VagrantError" do
+      @env["vagrant.error"] = Vagrant::Errors::VMImportFailure.new
+      @env.env.actions.expects(:run).never
+      @middleware.recover(@env)
+    end
+
+    should "not run the destroy action on recover if VM is not created" do
+      @env.env.vm.stubs(:created?).returns(false)
+      @env.env.actions.expects(:run).never
+      @middleware.recover(@env)
+    end
+
+    should "run the destroy action on recover" do
+      @env.env.vm.stubs(:created?).returns(true)
+      @env.env.actions.expects(:run).with(:aws_destroy).once
+      @middleware.recover(@env)
+    end
+  end
+
+end
+

data/test/vagrant-aws/action/terminate_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class TerminateActionTest < Test::Unit::TestCase
+  setup do
+    @app, @env = action_env
+		@env.env.vm = VagrantAWS::VM.new(:env => @env.env, :name => "default")
+    @middleware = VagrantAWS::Action::Terminate.new(@app, @env)
+	
+		@internal_vm = mock("internal")
+    @env.env.vm.stubs(:vm).returns(@internal_vm)
+	end
+
+	should "destroy VM and attached images" do
+    @internal_vm.expects(:destroy).once
+    @env["vm"].expects(:vm=).with(nil).once
+    @app.expects(:call).with(@env).once
+    @middleware.call(@env)
+  end
+
+end

data/test/vagrant-aws/command_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class CommandTest < Test::Unit::TestCase
+  setup do
+    @env = vagrant_env
+  end
+
+	context "up" do
+				
+		should "run aws_up" do
+			@env.config.aws.key_name = "default"
+			@env.vms.values.each do |vm|
+				vm.env.actions.expects(:run).with(:aws_up, {'provision.enabled' => true}).once
+			end
+			@env.cli("aws","up")
+		end
+
+	end
+	
+end
+

data/test/vagrant-aws/config_test.rb

@@ -0,0 +1,14 @@
+require "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  setup do
+    @config = VagrantAWS::Config.new
+		@errors = Vagrant::Config::ErrorRecorder.new
+  end
+
+	should "be valid by default" do
+    @config.validate(@errors)
+    assert @errors.errors.empty?
+  end
+	
+end