vagrant-aws 0.0.1 → 0.1.0

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

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

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

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

@@ -1,186 +0,0 @@
-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/environment.rb

@@ -1,79 +0,0 @@
-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/middleware.rb

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

data/lib/vagrant-aws/system.rb

@@ -1,24 +0,0 @@
-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/vm.rb

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