vagrant 0.1.4 → 0.2.0.pre

data/lib/vagrant/actions/vm/up.rb

@@ -11,13 +11,17 @@ virtual machine already exists and is not a file! The dotfile is
 currently configured to be `#{Env.dotfile_path}`
 
 To change this value, please see `config.vagrant.dotfile_name`
+
+This often exists if you're trying to create a Vagrant virtual
+environment from your home directory. To resolve this, you can either
+modify the configuration a bit, or simply use a different directory.
 msg
           end
 
           # Up is a "meta-action" so it really just queues up a bunch
           # of other actions in its place:
-          steps = [Import, ForwardPorts, SharedFolders, Boot]
-          steps << Provision if Vagrant.config.chef.enabled
+          steps = [Import, Customize, ForwardPorts, SharedFolders, Boot]
+          steps << Provision if !Vagrant.config.vm.provisioner.nil?
           steps.insert(0, MoveHardDrive) if Vagrant.config.vm.hd_location
 
           steps.each do |action_klass|
@@ -31,8 +35,8 @@ msg
         end
 
         def persist
-          logger.info "Persisting the VM UUID (#{@runner.vm.uuid})..."
-          Env.persist_vm(@runner.vm)
+          logger.info "Persisting the VM UUID (#{@runner.uuid})..."
+          Env.persist_vm(@runner)
         end
 
         def setup_mac_address

data/lib/vagrant/active_list.rb

@@ -0,0 +1,66 @@
+module Vagrant
+  # This class represents the active list of vagrant virtual
+  # machines.
+  class ActiveList
+    FILENAME = "active.json"
+
+    @@list = nil
+
+    class <<self
+      # Parses and returns the list of UUIDs from the active VM
+      # JSON file. This will cache the result, which can be reloaded
+      # by setting the `reload` parameter to true.
+      #
+      # @return [Array<String>]
+      def list(reload = false)
+        return @@list unless @@list.nil? || reload
+
+        @@list ||= []
+        return @@list unless File.file?(path)
+        File.open(path, "r") do |f|
+          @@list = JSON.parse(f.read)
+        end
+
+        @@list
+      end
+
+      # Returns an array of {Vagrant::VM} objects which are currently
+      # active.
+      def vms
+        list.collect { |uuid| Vagrant::VM.find(uuid) }.compact
+      end
+
+      # Returns an array of UUIDs filtered so each is verified to exist.
+      def filtered_list
+        vms.collect { |vm| vm.uuid }
+      end
+
+      # Adds a virtual environment to the list of active virtual machines
+      def add(vm)
+        list << vm.uuid
+        list.uniq!
+        save
+      end
+
+      # Remove a virtual environment from the list of active virtual machines
+      def remove(vm)
+        vm = vm.uuid if vm.is_a?(Vagrant::VM)
+        list.delete(vm)
+        save
+      end
+
+      # Persists the list down to the JSON file.
+      def save
+        File.open(path, "w+") do |f|
+          f.write(filtered_list.to_json)
+        end
+      end
+
+      # Returns the path to the JSON file which holds the UUIDs of the
+      # active virtual machines managed by Vagrant.
+      def path
+        File.join(Env.home_path, FILENAME)
+      end
+    end
+  end
+end

data/lib/vagrant/commands.rb

@@ -24,6 +24,49 @@ error
         FileUtils.cp(File.join(PROJECT_ROOT, "templates", Env::ROOTFILE_NAME), rootfile_path)
       end
 
+      # Outputs the status of the current environment. This command outputs
+      # useful information such as whether or not the environment is created
+      # and if its running, suspended, etc.
+      def status
+        Env.load!
+
+        wrap_output do
+          if !Env.persisted_vm
+            puts <<-msg
+The environment has not yet been created. Run `vagrant up` to create the
+environment.
+msg
+          else
+            additional_msg = ""
+            if Env.persisted_vm.vm.running?
+              additional_msg = <<-msg
+To stop this VM, you can run `vagrant halt` to shut it down forcefully,
+or you can run `vagrant suspend` to simply suspend the virtual machine.
+In either case, to restart it again, simply run a `vagrant up`.
+msg
+            elsif Env.persisted_vm.vm.saved?
+              additional_msg = <<-msg
+To resume this VM, simply run `vagrant up`.
+msg
+            elsif Env.persisted_vm.vm.powered_off?
+              additional_msg = <<-msg
+To restart this VM, simply run `vagrant up`.
+msg
+            end
+
+            if !additional_msg.empty?
+              additional_msg.chomp!
+              additional_msg = "\n\n#{additional_msg}"
+            end
+
+            puts <<-msg
+The environment has been created. The status of the current environment's
+virtual machine is: "#{Env.persisted_vm.vm.state}."#{additional_msg}
+msg
+          end
+        end
+      end
+
       # Bring up a vagrant instance. This handles everything from importing
       # the base VM, setting up shared folders, forwarded ports, etc to
       # provisioning the instance with chef. {up} also starts the instance,
@@ -139,6 +182,7 @@ Please specify a valid action to take on the boxes, either
 
 vagrant box add name uri
 vagrant box remove name
+vagrant box list
 error
         end
 

data/lib/vagrant/config.rb

@@ -4,32 +4,30 @@ module Vagrant
   end
 
   class Config
-    @config = nil
-    @config_runners = []
+    extend StackedProcRunner
+
+    @@config = nil
 
     class << self
       def reset!
-        @config = nil
-        config_runners.clear
+        @@config = nil
+        proc_stack.clear
       end
 
-      def config
-        @config ||= Config::Top.new
+      def configures(key, klass)
+        config.class.configures(key, klass)
       end
 
-      def config_runners
-        @config_runners ||= []
+      def config
+        @@config ||= Config::Top.new
       end
 
       def run(&block)
-        config_runners << block
+        push_proc(&block)
       end
 
       def execute!
-        config_runners.each do |block|
-          block.call(config)
-        end
-
+        run_procs!(config)
         config.loaded!
       end
     end
@@ -60,20 +58,32 @@ module Vagrant
       attr_accessor :forwarded_port_key
       attr_accessor :max_tries
       attr_accessor :timeout
+      attr_accessor :private_key_path
+
+      def private_key_path
+        File.expand_path(@private_key_path, Env.root_path)
+      end
     end
 
     class VMConfig < Base
+      include StackedProcRunner
+
       attr_accessor :box
       attr_accessor :box_ovf
       attr_accessor :base_mac
       attr_accessor :project_directory
       attr_reader :forwarded_ports
+      attr_reader :shared_folders
       attr_accessor :hd_location
       attr_accessor :disk_image_format
-
+      attr_accessor :provisioner
+      attr_accessor :shared_folder_uid
+      attr_accessor :shared_folder_gid
 
       def initialize
         @forwarded_ports = {}
+        @shared_folders = {}
+        @provisioner = nil
       end
 
       def forward_port(name, guestport, hostport, protocol="TCP")
@@ -84,13 +94,28 @@ module Vagrant
         }
       end
 
+      def share_folder(name, guestpath, hostpath)
+        @shared_folders[name] = {
+          :guestpath => guestpath,
+          :hostpath => hostpath
+        }
+      end
+
       def hd_location=(val)
-        raise Exception.new "disk_storage must be set to a directory" unless File.directory?(val)
+        raise Exception.new("disk_storage must be set to a directory") unless File.directory?(val)
         @hd_location=val
       end
 
-      def base
-        File.expand_path(@base)
+      def shared_folder_uid
+        @shared_folder_uid || Vagrant.config.ssh.username
+      end
+
+      def shared_folder_gid
+        @shared_folder_gid || Vagrant.config.ssh.username
+      end
+
+      def customize(&block)
+        push_proc(&block)
       end
     end
 
@@ -99,48 +124,40 @@ module Vagrant
       attr_accessor :extension
     end
 
-    class ChefConfig < Base
-      attr_accessor :cookbooks_path
-      attr_accessor :provisioning_path
-      attr_accessor :json
-      attr_accessor :enabled
-
-      def initialize
-        @enabled = false
-      end
-
-      def to_json
-        # Overridden so that the 'json' key could be removed, since its just
-        # merged into the config anyways
-        data = instance_variables_hash
-        data.delete(:json)
-        data.to_json
-      end
-    end
-
     class VagrantConfig < Base
       attr_accessor :dotfile_name
       attr_accessor :log_output
       attr_accessor :home
 
       def home
-        File.expand_path(@home)
+        @home ? File.expand_path(@home) : nil
       end
     end
 
     class Top < Base
-      attr_reader :package
-      attr_reader :ssh
-      attr_reader :vm
-      attr_reader :chef
-      attr_reader :vagrant
+      @@configures = []
+
+      class <<self
+        def configures_list
+          @@configures ||= []
+        end
+
+        def configures(key, klass)
+          configures_list << [key, klass]
+          attr_reader key.to_sym
+        end
+      end
+
+      # Setup default configures
+      configures :package, PackageConfig
+      configures :ssh, SSHConfig
+      configures :vm, VMConfig
+      configures :vagrant, VagrantConfig
 
       def initialize
-        @ssh = SSHConfig.new
-        @vm = VMConfig.new
-        @chef = ChefConfig.new
-        @vagrant = VagrantConfig.new
-        @package = PackageConfig.new
+        self.class.configures_list.each do |key, klass|
+          instance_variable_set("@#{key}".to_sym, klass.new)
+        end
 
         @loaded = false
       end

data/lib/vagrant/downloaders/file.rb

@@ -3,19 +3,9 @@ module Vagrant
     # "Downloads" a file to a temporary file. Basically, this downloader
     # simply does a file copy.
     class File < Base
-      BUFFERSIZE = 1048576 # 1 MB
-
       def download!(source_url, destination_file)
-        # For now we read the contents of one into a buffer
-        # and copy it into the other. In the future, we should do
-        # a system-level file copy (FileUtils.cp).
-        open(source_url) do |f|
-          loop do
-            break if f.eof?
-            destination_file.write(f.read(BUFFERSIZE))
-          end
-        end
+        FileUtils.cp(source_url, destination_file.path)
       end
     end
   end
-end
+end

data/lib/vagrant/env.rb

@@ -24,21 +24,52 @@ module Vagrant
         load_config!
         load_home_directory!
         load_box!
+        load_config!
+        check_virtualbox!
         load_vm!
       end
 
+      def check_virtualbox!
+        version = VirtualBox::Command.version
+        if version.nil?
+          error_and_exit(<<-msg)
+Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.
+If VirtualBox is installed, you may need to tweak the paths to the `VBoxManage`
+application which ships with VirtualBox and the path to the global XML configuration
+which VirtualBox typically stores somewhere in your home directory.
+
+The following shows how to configure VirtualBox. This can be done in the
+Vagrantfile. Note that 90% of the time, you shouldn't need to do this if VirtualBox
+is installed. Please use the various Vagrant support lines to request more information
+if you can't get this working.
+
+VirtualBox::Command.vboxmanage = "/path/to/my/VBoxManage"
+VirtualBox::Global.vboxconfig = "~/path/to/VirtualBox.xml"
+msg
+        elsif version.to_f < 3.1
+          error_and_exit(<<-msg)
+Vagrant has detected that you have VirtualBox version #{version} installed!
+Vagrant requires that you use at least VirtualBox version 3.1. Please install
+a more recent version of VirtualBox to continue.
+msg
+        end
+      end
+
       def load_config!
         # Prepare load paths for config files
         load_paths = [File.join(PROJECT_ROOT, "config", "default.rb")]
         load_paths << File.join(box.directory, ROOTFILE_NAME) if box
+        load_paths << File.join(home_path, ROOTFILE_NAME) if Vagrant.config.vagrant.home
         load_paths << File.join(root_path, ROOTFILE_NAME) if root_path
 
         # Then clear out the old data
         Config.reset!
 
         load_paths.each do |path|
-          logger.info "Loading config from #{path}..."
-          load path if File.exist?(path)
+          if File.exist?(path)
+            logger.info "Loading config from #{path}..."
+            load path
+          end
         end
 
         # Execute the configurations
@@ -63,11 +94,6 @@ module Vagrant
         return unless root_path
 
         @@box = Box.find(Vagrant.config.vm.box) if Vagrant.config.vm.box
-
-        if @@box
-          logger.info("Reloading configuration to account for loaded box...")
-          load_config!
-        end
       end
 
       def load_vm!
@@ -81,18 +107,28 @@ module Vagrant
       end
 
       def persist_vm(vm)
+        # Save to the dotfile for this project
         File.open(dotfile_path, 'w+') do |f|
           f.write(vm.uuid)
         end
+
+        # Also add to the global store
+        ActiveList.add(vm)
+      end
+
+      def depersist_vm(vm)
+        # Delete the dotfile if it exists
+        File.delete(dotfile_path) if File.exist?(dotfile_path)
+
+        # Remove from the global store
+        ActiveList.remove(vm)
       end
 
       def load_root_path!(path=nil)
-        path ||= Pathname.new(Dir.pwd)
+        path = Pathname.new(File.expand_path(path || Dir.pwd))
 
-        # Stop if we're at the root. 2nd regex matches windows drives
-        # such as C:. and Z:. Portability of this check will need to be
-        # researched.
-        return false if path.to_s == '/' || path.to_s =~ /^[A-Z]:\.$/
+        # Stop if we're at the root.
+        return false if path.root?
 
         file = "#{path}/#{ROOTFILE_NAME}"
         if File.exist?(file)

data/lib/vagrant/provisioners/base.rb

@@ -0,0 +1,22 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system. This has been abstracted out to provide
+    # support for multiple solutions such as Chef Solo, Chef Client, and
+    # Puppet.
+    class Base
+      include Vagrant::Util
+
+      # This is the method called to "prepare" the provisioner. This is called
+      # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
+      # This can be used to setup shared folders, forward ports, etc. Whatever is
+      # necessary on a "meta" level.
+      def prepare; end
+
+      # This is the method called to provision the system. This method
+      # is expected to do whatever necessary to provision the system (create files,
+      # SSH, etc.)
+      def provision!; end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -0,0 +1,102 @@
+module Vagrant
+  module Provisioners
+    # This class is a base class where the common functinality shared between
+    # chef-solo and chef-client provisioning are stored. This is **not an actual
+    # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      # This is the configuration which is available through `config.chef`
+      class ChefConfig < Vagrant::Config::Base
+        # Chef server specific config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+
+        # Chef solo specific config
+        attr_accessor :cookbooks_path
+
+        # Shared config
+        attr_accessor :provisioning_path
+        attr_accessor :json
+
+        def initialize
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+
+          @cookbooks_path = "cookbooks"
+          @provisioning_path = "/tmp/vagrant-chef"
+          @json = {
+            :instance_role => "vagrant",
+            :run_list => ["recipe[vagrant_main]"]
+          }
+        end
+
+        # Returns the run list for the provisioning
+        def run_list
+          json[:run_list]
+        end
+
+        # Sets the run list to the specified value
+        def run_list=(value)
+          json[:run_list] = value
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+          run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+          run_list << name
+        end
+
+        def to_json
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          data = instance_variables_hash
+          data.delete(:json)
+          data.to_json
+        end
+      end
+
+      # Tell the Vagrant configure class about our custom configuration
+      Config.configures :chef, ChefConfig
+
+      def prepare
+        raise Actions::ActionException.new("Vagrant::Provisioners::Chef is not a valid provisioner! Use ChefSolo or ChefServer instead.")
+      end
+
+      def chown_provisioning_folder
+        logger.info "Setting permissions on chef provisioning folder..."
+        SSH.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{Vagrant.config.chef.provisioning_path}")
+          ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
+        end
+      end
+
+      def setup_json
+        logger.info "Generating chef JSON and uploading..."
+
+        # Set up initial configuration
+        data = {
+          :config => Vagrant.config,
+          :directory => Vagrant.config.vm.project_directory,
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(Vagrant.config.chef.json)
+
+        json = data.to_json
+
+        SSH.upload!(StringIO.new(json), File.join(Vagrant.config.chef.provisioning_path, "dna.json"))
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_server.rb

@@ -0,0 +1,96 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-client, allowing provisioning
+    # with a chef server.
+    class ChefServer < Chef
+      def prepare
+        if Vagrant.config.chef.validation_key_path.nil?
+          raise Actions::ActionException.new(<<-msg)
+Chef server provisioning requires that the `config.chef.validation_key_path` configuration
+be set to a path on your local machine of the validation key used to register the
+VM with the chef server.
+msg
+        elsif !File.file?(Vagrant.config.chef.validation_key_path)
+          raise Actions::ActionException.new(<<-msg)
+The validation key set for `config.chef.validation_key_path` does not exist! This
+file needs to exist so it can be uploaded to the virtual machine. It is
+currently set to "#{Vagrant.config.chef.validation_key_path}"
+msg
+        end
+
+        if Vagrant.config.chef.chef_server_url.nil?
+          raise Actions::ActionException.new(<<-msg)
+Chef server provisioning requires that the `config.chef.chef_server_url` be set to the
+URL of your chef server. Examples include "http://12.12.12.12:4000" and
+"http://myserver.com:4000" (the port of course can be different, but 4000 is the default)
+msg
+        end
+      end
+
+      def provision!
+        chown_provisioning_folder
+        create_client_key_folder
+        upload_validation_key
+        setup_json
+        setup_config
+        run_chef_client
+      end
+
+      def create_client_key_folder
+        logger.info "Creating folder to hold client key..."
+        path = Pathname.new(Vagrant.config.chef.client_key_path)
+
+        SSH.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        logger.info "Uploading chef client validation key..."
+        SSH.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def setup_config
+        solo_file = <<-solo
+log_level          :info
+log_location       STDOUT
+ssl_verify_mode    :verify_none
+chef_server_url    "#{Vagrant.config.chef.chef_server_url}"
+
+validation_client_name "#{Vagrant.config.chef.validation_client_name}"
+validation_key         "#{guest_validation_key_path}"
+client_key             "#{Vagrant.config.chef.client_key_path}"
+
+file_store_path    "/srv/chef/file_store"
+file_cache_path    "/srv/chef/cache"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true
+solo
+
+        logger.info "Uploading chef-client configuration script..."
+        SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "client.rb"))
+      end
+
+      def run_chef_client
+        logger.info "Running chef-client..."
+        SSH.execute do |ssh|
+          ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json") do |channel, data, stream|
+            # TODO: Very verbose. It would be easier to save the data and only show it during
+            # an error, or when verbosity level is set high
+            logger.info("#{stream}: #{data}")
+          end
+        end
+      end
+
+      def validation_key_path
+        File.expand_path(Vagrant.config.chef.validation_key_path, Env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(Vagrant.config.chef.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end