vagrant 0.3.4 → 0.4.0

data/lib/vagrant/downloaders/http.rb

@@ -1,10 +1,13 @@
+require 'net/http'
+require 'net/https'
+require 'open-uri'
+require 'uri'
+
 module Vagrant
   module Downloaders
     # Downloads a file from an HTTP URL to a temporary file. This
     # downloader reports its progress to stdout while downloading.
     class HTTP < Base
-      include Util::ProgressMeter
-
       def self.match?(uri)
         # URI.parse barfs on '<drive letter>:\\files \on\ windows'
         # TODO temprorary
@@ -13,29 +16,38 @@ module Vagrant
       end
 
       def download!(source_url, destination_file)
-        Net::HTTP.get_response(URI.parse(source_url)) do |response|
-          total = response.content_length
-          progress = 0
-          segment_count = 0
+        uri = URI.parse(source_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == "https"
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
 
-          response.read_body do |segment|
-            # Report the progress out
-            progress += segment.length
-            segment_count += 1
+        http.start do |h|
+          h.request_get(uri.request_uri) do |response|
+            total = response.content_length
+            progress = 0
+            segment_count = 0
 
-            # Progress reporting is limited to every 25 segments just so
-            # we're not constantly updating
-            if segment_count % 25 == 0
-              update_progress(progress, total)
-              segment_count = 0
-            end
+            response.read_body do |segment|
+              # Report the progress out
+              progress += segment.length
+              segment_count += 1
+
+              # Progress reporting is limited to every 25 segments just so
+              # we're not constantly updating
+              if segment_count % 25 == 0
+                env.logger.report_progress(progress, total)
+                segment_count = 0
+              end
 
-            # Store the segment
-            destination_file.write(segment)
+              # Store the segment
+              destination_file.write(segment)
+            end
           end
         end
 
-        complete_progress
+        env.logger.clear_progress
       end
     end
   end

data/lib/vagrant/environment.rb

@@ -5,27 +5,32 @@ module Vagrant
   class Environment
     ROOTFILE_NAME = "Vagrantfile"
     HOME_SUBDIRS = ["tmp", "boxes"]
+    DEFAULT_VM = :default
 
     include Util
 
+    attr_reader :parent     # Parent environment (in the case of multi-VMs)
+    attr_reader :vm_name    # The name of the VM (internal name) which this environment represents
+
     attr_accessor :cwd
     attr_reader :root_path
     attr_reader :config
     attr_reader :box
     attr_accessor :vm
-    attr_reader :ssh
+    attr_reader :vms
     attr_reader :active_list
     attr_reader :commands
+    attr_reader :logger
 
     #---------------------------------------------------------------
     # Class Methods
     #---------------------------------------------------------------
-    class <<self
+    class << self
       # Loads and returns an environment given a specific working
       # directory. If a working directory is not given, it will default
       # to the pwd.
       def load!(cwd=nil)
-        Environment.new(cwd).load!
+        Environment.new(:cwd => cwd).load!
       end
 
       # Verifies that VirtualBox is installed and that the version of
@@ -43,12 +48,23 @@ module Vagrant
       end
     end
 
-    def initialize(cwd=nil)
-      @cwd = cwd
+    def initialize(opts=nil)
+      defaults = {
+        :parent => nil,
+        :vm_name => nil,
+        :vm => nil,
+        :cwd => nil
+      }
+
+      opts = defaults.merge(opts || {})
+
+      defaults.each do |key, value|
+        instance_variable_set("@#{key}".to_sym, opts[key])
+      end
     end
 
     #---------------------------------------------------------------
-    # Path Helpers
+    # Helpers
     #---------------------------------------------------------------
 
     # Specifies the "current working directory" for this environment.
@@ -62,7 +78,7 @@ module Vagrant
     # The path to the `dotfile`, which contains the persisted UUID of
     # the VM if it exists.
     def dotfile_path
-      File.join(root_path, config.vagrant.dotfile_name)
+      root_path ? File.join(root_path, config.vagrant.dotfile_name) : nil
     end
 
     # The path to the home directory, which is usually in `~/.vagrant/~
@@ -80,6 +96,34 @@ module Vagrant
       File.join(home_path, "boxes")
     end
 
+    # Returns the VMs associated with this environment.
+    def vms
+      @vms ||= {}
+    end
+
+    # Returns the primray VM associated with this environment
+    def primary_vm
+      return vms.values.first if !multivm?
+      return parent.primary_vm if parent
+
+      config.vm.defined_vms.each do |name, subvm|
+        return vms[name] if subvm.options[:primary]
+      end
+
+      nil
+    end
+
+    # Returns a boolean whether this environment represents a multi-VM
+    # environment or not. This will work even when called on child
+    # environments.
+    def multivm?
+      if parent
+        parent.multivm?
+      else
+        vms.length > 1
+      end
+    end
+
     #---------------------------------------------------------------
     # Load Methods
     #---------------------------------------------------------------
@@ -88,6 +132,7 @@ module Vagrant
     # such as `vm`, `config`, etc. on this environment. The order this
     # method calls its other methods is very particular.
     def load!
+      load_logger!
       load_root_path!
       load_config!
       load_home_directory!
@@ -95,7 +140,6 @@ module Vagrant
       load_config!
       self.class.check_virtualbox!
       load_vm!
-      load_ssh!
       load_active_list!
       load_commands!
       self
@@ -125,25 +169,54 @@ module Vagrant
     # this environment, meaning that it will use the given root directory
     # to load the Vagrantfile into that context.
     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 home_path
-      load_paths << File.join(root_path, ROOTFILE_NAME) if root_path
+      # Prepare load paths for config files and append to config queue
+      config_queue = [File.join(PROJECT_ROOT, "config", "default.rb")]
+      config_queue << File.join(box.directory, ROOTFILE_NAME) if box
+      config_queue << File.join(home_path, ROOTFILE_NAME) if home_path
+      config_queue << File.join(root_path, ROOTFILE_NAME) if root_path
+
+      # If this environment represents some VM in a multi-VM environment,
+      # we push that VM's configuration onto the config_queue.
+      if vm_name
+        subvm = parent.config.vm.defined_vms[vm_name]
+        config_queue << subvm.proc_stack if subvm
+      end
+
+      # Flatten the config queue so any nested procs are flattened
+      config_queue.flatten!
 
       # Clear out the old data
       Config.reset!(self)
 
       # Load each of the config files in order
-      load_paths.each do |path|
-        if File.exist?(path)
-          logger.info "Loading config from #{path}..."
-          load path
+      config_queue.each do |item|
+        if item.is_a?(String) && File.exist?(item)
+          load item
+          next
+        end
+
+        if item.is_a?(Proc)
+          # Just push the proc straight onto the config runnable stack
+          Config.run(&item)
         end
       end
 
       # Execute the configuration stack and store the result
       @config = Config.execute!
+
+      # (re)load the logger
+      load_logger!
+    end
+
+    # Loads the logger for this environment. This is called by
+    # {#load_config!} so that the logger is only loaded after
+    # configuration information is available. The logger is also
+    # loaded early on in the load chain process so that the various
+    # references to logger won't throw nil exceptions, but by default
+    # the logger will just send the log data to a black hole.
+    def load_logger!
+      resource = vm_name || "vagrant"
+      @logger = ResourceLogger.new(resource, self)
     end
 
     # Loads the home directory path and creates the necessary subdirectories
@@ -171,19 +244,49 @@ module Vagrant
 
     # Loads the persisted VM (if it exists) for this environment.
     def load_vm!
-      return if !root_path || !File.file?(dotfile_path)
+      # This environment represents a single sub VM. The VM is then
+      # probably (read: should be) set on the VM attribute, so we do
+      # nothing.
+      return if vm_name
+
+      # First load the defaults (blank, noncreated VMs)
+      load_blank_vms!
 
+      # If we have no dotfile, then return
+      return if !dotfile_path || !File.file?(dotfile_path)
+
+      # Open and parse the dotfile
       File.open(dotfile_path) do |f|
-        @vm = Vagrant::VM.find(f.read)
-        @vm.env = self if @vm
+        data = { DEFAULT_VM => f.read }
+
+        begin
+          data = JSON.parse(data[DEFAULT_VM])
+        rescue JSON::ParserError
+          # Most likely an older (<= 0.3.x) dotfile. Try to load it
+          # as the :__vagrant VM.
+        end
+
+        data.each do |key, value|
+          key = key.to_sym
+          vms[key] = Vagrant::VM.find(value, self, key)
+        end
       end
     rescue Errno::ENOENT
-      @vm = nil
+      # Just rescue it.
     end
 
-    # Loads/initializes the SSH object
-    def load_ssh!
-      @ssh = SSH.new(self)
+    # Loads blank VMs into the `vms` attribute.
+    def load_blank_vms!
+      # Clear existing vms
+      vms.clear
+
+      # Load up the blank VMs
+      defined_vms = config.vm.defined_vms.keys
+      defined_vms = [DEFAULT_VM] if defined_vms.empty?
+
+      defined_vms.each do |name|
+        vms[name] = Vagrant::VM.new(:vm_name => name, :env => self)
+      end
     end
 
     # Loads the activelist for this environment
@@ -202,34 +305,28 @@ module Vagrant
     # Methods to manage VM
     #---------------------------------------------------------------
 
-    # Sets the VM to a new VM. This is not too useful but is used
-    # in {Command.up}. This will very likely be refactored at a later
-    # time.
-    def create_vm
-      @vm = VM.new
-      @vm.env = self
-      @vm
-    end
-
     # Persists this environment's VM to the dotfile so it can be
     # re-loaded at a later time.
-    def persist_vm
-      # Save to the dotfile for this project
-      File.open(dotfile_path, 'w+') do |f|
-        f.write(vm.uuid)
+    def update_dotfile
+      return parent.update_dotfile if parent
+
+      # Generate and save the persisted VM info
+      data = vms.inject({}) do |acc, data|
+        key, value = data
+        acc[key] = value.uuid if value.created?
+        acc
       end
 
-      # Also add to the global store
-      active_list.add(vm)
-    end
-
-    # Removes this environment's VM from the dotfile.
-    def depersist_vm
-      # Delete the dotfile if it exists
-      File.delete(dotfile_path) if File.exist?(dotfile_path)
+      if data.empty?
+        File.delete(dotfile_path)
+      else
+        File.open(dotfile_path, 'w+') do |f|
+          f.write(data.to_json)
+        end
+      end
 
-      # Remove from the global store
-      active_list.remove(vm)
+      # Also add to the global store
+      # active_list.add(vm)
     end
 
     #---------------------------------------------------------------
@@ -244,10 +341,10 @@ module Vagrant
       require_root_path
 
       if !box
-        if !Vagrant.config.vm.box
+        if !config.vm.box
           error_and_exit(:box_not_specified)
         else
-          error_and_exit(:box_specified_doesnt_exist, :box_name => Vagrant.config.vm.box)
+          error_and_exit(:box_specified_doesnt_exist, :box_name => config.vm.box)
         end
       end
     end

data/lib/vagrant/provisioners/base.rb

@@ -7,11 +7,25 @@ module Vagrant
     class Base
       include Vagrant::Util
 
-      # The environment which this is being provisioned in
-      attr_reader :env
+      # The VM which this is being provisioned for
+      attr_reader :vm
 
-      def initialize(env)
-        @env = env
+      def initialize(vm)
+        @vm = vm
+      end
+
+      # This method returns the environment which the provisioner is working
+      # on. This is also the environment of the VM. This method is provided
+      # as a simple helper since the environment is often used throughout the
+      # provisioner.
+      def env
+        @vm.env
+      end
+
+      # This method returns the environment's logger as a convenience
+      # method.
+      def logger
+        env.logger
       end
 
       # This is the method called to "prepare" the provisioner. This is called
@@ -26,4 +40,4 @@ module Vagrant
       def provision!; end
     end
   end
-end
+end

data/lib/vagrant/provisioners/chef.rb

@@ -75,9 +75,17 @@ module Vagrant
         raise Actions::ActionException.new(:chef_base_invalid_provisioner)
       end
 
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          # Checks for the existence of chef binary and error if it
+          # doesn't exist.
+          ssh.exec!("which #{binary}", :error_key => :chef_not_detected, :error_data => {:binary => binary})
+        end
+      end
+
       def chown_provisioning_folder
         logger.info "Setting permissions on chef provisioning folder..."
-        env.ssh.execute do |ssh|
+        vm.ssh.execute do |ssh|
           ssh.exec!("sudo mkdir -p #{env.config.chef.provisioning_path}")
           ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.chef.provisioning_path}")
         end
@@ -89,7 +97,7 @@ module Vagrant
         }.merge(template_vars))
 
         logger.info "Uploading chef configuration script..."
-        env.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
+        vm.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
       end
 
       def setup_json
@@ -98,7 +106,7 @@ module Vagrant
         # Set up initial configuration
         data = {
           :config => env.config,
-          :directory => env.config.vm.project_directory,
+          :directory => env.config.vm.shared_folders["v-root"][:guestpath],
         }
 
         # And wrap it under the "vagrant" namespace
@@ -110,7 +118,7 @@ module Vagrant
 
         json = data.to_json
 
-        env.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
+        vm.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
       end
     end
   end