vagrantup 0.1.4 → 0.2.0

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

@@ -2,6 +2,30 @@ module Vagrant
   module Actions
     module VM
       class ForwardPorts < Base
+        def prepare
+          VirtualBox::VM.all.each do |vm|
+            next if !vm.running? || vm.uuid == @runner.uuid
+
+            vm.forwarded_ports.each do |fp|
+              Vagrant.config.vm.forwarded_ports.each do |name, options|
+                if fp.hostport.to_s == options[:hostport].to_s
+                  raise ActionException.new(<<-msg)
+Vagrant cannot forward the specified ports on this VM, since they
+would collide with another VirtualBox virtual machine's forwarded
+ports! The "#{name}" forwarded port (#{fp.hostport}) is already in use on the host
+machine.
+
+To fix this, modify your current projects Vagrantfile to use another
+port. Example, where '1234' would be replaced by a unique host port:
+
+config.vm.forward_port("#{name}", #{options[:guestport]}, 1234)
+msg
+                end
+              end
+            end
+          end
+        end
+
         def execute!
           clear
           forward_ports

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

@@ -8,6 +8,7 @@ module Vagrant
               logger.info "Importing base VM (#{Vagrant::Env.box.ovf_file})..."
               # Use the first argument passed to the action
               @runner.vm = VirtualBox::VM.import(Vagrant::Env.box.ovf_file)
+              raise ActionException.new("The VM import failed! Try running `VBoxManage import` on the box file manually for more verbose error output.") unless @runner.vm
             end
           end
         end

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

@@ -2,68 +2,46 @@ module Vagrant
   module Actions
     module VM
       class Provision < Base
-        def execute!
-          chown_provisioning_folder
-          setup_json
-          setup_solo_config
-          run_chef_solo
-        end
-
-        def chown_provisioning_folder
-          logger.info "Setting permissions on provisioning folder..."
-          SSH.execute do |ssh|
-            ssh.exec!("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}")
-          end
-        end
-
-        def setup_json
-          logger.info "Generating JSON and uploading..."
-
-          # Set up initial configuration
-          data = {
-            :config => Vagrant.config,
-            :directory => Vagrant.config.vm.project_directory,
-          }
+        attr_reader :provisioner
 
-          # And wrap it under the "vagrant" namespace
-          data = { :vagrant => data }
+        def intialize(*args)
+          super
 
-          # 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"))
+          @provisioner = nil
         end
 
-        def setup_solo_config
-          solo_file = <<-solo
-file_cache_path "#{Vagrant.config.chef.provisioning_path}"
-cookbook_path "#{cookbooks_path}"
-solo
+        def prepare
+          provisioner = Vagrant.config.vm.provisioner
 
-          logger.info "Uploading chef-solo configuration script..."
-          SSH.upload!(StringIO.new(solo_file), File.join(Vagrant.config.chef.provisioning_path, "solo.rb"))
-        end
+          if provisioner.nil?
+            logger.info("Provisioning not enabled, ignoring this step")
+            return
+          end
 
-        def run_chef_solo
-          logger.info "Running chef recipes..."
-          SSH.execute do |ssh|
-            ssh.exec!("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.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
+          if provisioner.is_a?(Class)
+            @provisioner = provisioner.new
+            raise ActionException.new("Provisioners must be an instance of Vagrant::Provisioners::Base") unless @provisioner.is_a?(Provisioners::Base)
+          elsif provisioner.is_a?(Symbol)
+            # We have a few hard coded provisioners for built-ins
+            mapping = {
+              :chef_solo    => Provisioners::ChefSolo,
+              :chef_server  => Provisioners::ChefServer
+            }
+
+            provisioner_klass = mapping[provisioner]
+            raise ActionException.new("Unknown provisioner type: #{provisioner}") if provisioner_klass.nil?
+            @provisioner = provisioner_klass.new
           end
-        end
 
-        def cookbooks_path
-          File.join(Vagrant.config.chef.provisioning_path, "cookbooks")
+          logger.info "Provisioning enabled with #{@provisioner.class}"
+          @provisioner.prepare
         end
 
-        def collect_shared_folders
-          ["vagrant-provisioning", File.expand_path(Vagrant.config.chef.cookbooks_path, Env.root_path), cookbooks_path]
+        def execute!
+          if provisioner
+            logger.info "Beginning provisioning process..."
+            provisioner.provision!
+          end
         end
       end
     end

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

@@ -3,9 +3,9 @@ module Vagrant
     module VM
       class Reload < Base
         def prepare
-          steps = [ForwardPorts, SharedFolders, Boot]
+          steps = [Customize, ForwardPorts, SharedFolders, Boot]
           steps.unshift(Halt) if @runner.vm.running?
-          steps << Provision if Vagrant.config.chef.enabled
+          steps << Provision if !Vagrant.config.vm.provisioner.nil?
 
           steps.each do |action_klass|
             @runner.add_action(action_klass)

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

@@ -3,32 +3,15 @@ module Vagrant
     module VM
       class SharedFolders < Base
         def shared_folders
-          shared_folders = @runner.invoke_callback(:collect_shared_folders)
-
-          # Basic filtering of shared folders. Basically only verifies that
-          # the result is an array of 3 elements. In the future this should
-          # also verify that the host path exists, the name is valid,
-          # and that the guest path is valid.
-          shared_folders.collect do |folder|
-            if folder.is_a?(Array) && folder.length == 3
-              folder
-            else
-              nil
-            end
-          end.compact
+          Vagrant.config.vm.shared_folders.inject([]) do |acc, data|
+            name, value = data
+            acc << [name, File.expand_path(value[:hostpath]), value[:guestpath]]
+          end
         end
 
         def before_boot
-          logger.info "Creating shared folders metadata..."
-
-          shared_folders.each do |name, hostpath, guestpath|
-            folder = VirtualBox::SharedFolder.new
-            folder.name = name
-            folder.hostpath = hostpath
-            @runner.vm.shared_folders << folder
-          end
-
-          @runner.vm.save(true)
+          clear_shared_folders
+          create_metadata
         end
 
         def after_boot
@@ -44,14 +27,43 @@ module Vagrant
           end
         end
 
+        def clear_shared_folders
+          logger.info "Clearing previously set shared folders..."
+
+          @runner.vm.shared_folders.each do |shared_folder|
+            shared_folder.destroy
+          end
+
+          @runner.reload!
+        end
+
+        def create_metadata
+          logger.info "Creating shared folders metadata..."
+
+          shared_folders.each do |name, hostpath, guestpath|
+            folder = VirtualBox::SharedFolder.new
+            folder.name = name
+            folder.hostpath = hostpath
+            @runner.vm.shared_folders << folder
+          end
+
+          @runner.vm.save(true)
+        end
+
         def mount_folder(ssh, name, guestpath, sleeptime=5)
           # Note: This method seems pretty OS-specific and could also use
           # some configuration options. For now its duct tape and "works"
           # but should be looked at in the future.
-          attempts = 0
 
+          # Determine the permission string to attach to the mount command
+          perms = []
+          perms << "uid=#{Vagrant.config.vm.shared_folder_uid}"
+          perms << "gid=#{Vagrant.config.vm.shared_folder_gid}"
+          perms = " -o #{perms.join(",")}" if !perms.empty?
+
+          attempts = 0
           while true
-            result = ssh.exec!("sudo mount -t vboxsf #{name} #{guestpath}") do |ch, type, data|
+            result = ssh.exec!("sudo mount -t vboxsf#{perms} #{name} #{guestpath}") do |ch, type, data|
               # net/ssh returns the value in ch[:result] (based on looking at source)
               ch[:result] = !!(type == :stderr && data =~ /No such device/i)
             end

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