vagrant 0.3.4 → 0.4.0

data/lib/vagrant/provisioners/chef_server.rb

@@ -16,6 +16,7 @@ module Vagrant
       end
 
       def provision!
+        verify_binary("chef-client")
         chown_provisioning_folder
         create_client_key_folder
         upload_validation_key
@@ -28,14 +29,14 @@ module Vagrant
         logger.info "Creating folder to hold client key..."
         path = Pathname.new(env.config.chef.client_key_path)
 
-        env.ssh.execute do |ssh|
+        vm.ssh.execute do |ssh|
           ssh.exec!("sudo mkdir -p #{path.dirname}")
         end
       end
 
       def upload_validation_key
         logger.info "Uploading chef client validation key..."
-        env.ssh.upload!(validation_key_path, guest_validation_key_path)
+        vm.ssh.upload!(validation_key_path, guest_validation_key_path)
       end
 
       def setup_server_config
@@ -49,12 +50,18 @@ module Vagrant
       end
 
       def run_chef_client
+        command = "cd #{env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json"
+
         logger.info "Running chef-client..."
-        env.ssh.execute do |ssh|
-          ssh.exec!("cd #{env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json") do |channel, data, stream|
+        vm.ssh.execute do |ssh|
+          ssh.exec!(command) do |channel, type, data|
             # 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}")
+            if type == :exit_status
+              ssh.check_exit_status(data, command)
+            else
+              logger.info("#{data}: #{type}")
+            end
           end
         end
       end
@@ -64,7 +71,7 @@ module Vagrant
       end
 
       def guest_validation_key_path
-        File.join(@env.config.chef.provisioning_path, "validation.pem")
+        File.join(env.config.chef.provisioning_path, "validation.pem")
       end
     end
   end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -8,6 +8,7 @@ module Vagrant
       end
 
       def provision!
+        verify_binary("chef-solo")
         chown_provisioning_folder
         setup_json
         setup_solo_config
@@ -35,12 +36,15 @@ module Vagrant
       end
 
       def run_chef_solo
+        command = "cd #{env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json"
+
         logger.info "Running chef-solo..."
-        env.ssh.execute do |ssh|
-          ssh.exec!("cd #{env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json") do |channel, data, stream|
+        vm.ssh.execute do |ssh|
+          ssh.exec!(command) do |channel, type, data|
             # 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}")
+            ssh.check_exit_status(data, command) if type == :exit_status
+            logger.info("#{data}: #{type}") if type != :exit_status
           end
         end
       end

data/lib/vagrant/resource_logger.rb

@@ -0,0 +1,126 @@
+require 'thread'
+
+module Vagrant
+  # Represents a logger for a specific resource within Vagrant. Each
+  # logger should be initialized and set to represent a single
+  # resource. Each logged message will then appear in the following
+  # format:
+  #
+  #     [resource] message
+  #
+  # This class is thread safe. The backing class which actually does
+  # all the logging IO is protected.
+  #
+  # This class also handles progress meters of multiple resources and
+  # handles all the proper interleaving and console updating to
+  # display the progress meters in a way which doesn't conflict with
+  # other incoming log messages.
+  class ResourceLogger
+    @@singleton_logger = nil
+    @@progress_reporters = nil
+    @@writer_lock = Mutex.new
+
+    # The resource which this logger represents.
+    attr_reader :resource
+
+    # The environment that this logger is part of
+    attr_reader :env
+
+    # The backing logger which actually handles the IO. This logger
+    # should be a subclass of the standard library Logger, in general.
+    # IMPORTANT: This logger must be thread-safe.
+    attr_reader :logger
+
+    class << self
+      # Returns a singleton logger. If one has not yet be
+      # instantiated, then the given environment will be used to
+      # create a new logger.
+      def singleton_logger(env=nil)
+        if env && env.config && env.config.loaded?
+          @@singleton_logger ||= Util::PlainLogger.new(env.config.vagrant.log_output)
+        else
+          Util::PlainLogger.new(nil)
+        end
+      end
+
+      # Resets the singleton logger (only used for testing).
+      def reset_singleton_logger!
+        @@singleton_logger = nil
+      end
+
+      # Returns the progress parts array which contains the various
+      # progress reporters.
+      def progress_reporters
+        @@progress_reporters ||= {}
+      end
+    end
+
+    def initialize(resource, env)
+      @resource = resource
+      @env = env
+      @logger = self.class.singleton_logger(env)
+    end
+
+    # TODO: The other logging methods.
+
+    def info(message)
+      @@writer_lock.synchronize do
+        # We clear the line in case progress reports have been going
+        # out.
+        print(cl_reset)
+        logger.info("[#{resource}] #{message}")
+      end
+
+      # Once again flush the progress reporters since we probably
+      # cleared any existing ones.
+      flush_progress
+    end
+
+    # Sets a progress report for the resource that this logger
+    # represents. This progress report is interleaved within the output.
+    def report_progress(progress, total, show_parts=true)
+      # Simply add the progress reporter to the list of progress
+      # reporters
+      self.class.progress_reporters[resource] = {
+        :progress => progress,
+        :total => total,
+        :show_parts => show_parts
+      }
+
+      # And force an update to occur
+      flush_progress
+    end
+
+    # Clears the progress report for this resource
+    def clear_progress
+      self.class.progress_reporters.delete(resource)
+    end
+
+    def flush_progress
+      # Don't do anything if there are no progress reporters
+      return if self.class.progress_reporters.length <= 0
+
+      @@writer_lock.synchronize do
+        reports = []
+
+        # First generate all the report percentages and output
+        self.class.progress_reporters.each do |name, data|
+          percent = (data[:progress].to_f / data[:total].to_f) * 100
+          line = "#{name}: #{percent.to_i}%"
+          line << " (#{data[:progress]} / #{data[:total]})" if data[:show_parts]
+          reports << line
+        end
+
+        # Output it to stdout
+        print "#{cl_reset}[progress] #{reports.join(" ")}"
+        $stdout.flush
+      end
+    end
+
+    def cl_reset
+      reset = "\r"
+      reset += "\e[0K" unless Mario::Platform.windows?
+      reset
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -48,8 +48,11 @@ module Vagrant
       Net::SSH.start(env.config.ssh.host,
                      env.config[:ssh][:username],
                      opts.merge( :port => port,
-                                 :keys => [env.config.ssh.private_key_path])) do |ssh|
-        yield ssh
+                                 :keys => [env.config.ssh.private_key_path],
+                                 :user_known_hosts_file => [],
+                                 :paranoid => false,
+                                 :config => false)) do |ssh|
+        yield SSH::Session.new(ssh)
       end
     end
 
@@ -57,9 +60,16 @@ module Vagrant
     # or StringIO, and `to` is expected to be a path. This method simply forwards
     # the arguments to `Net::SCP#upload!` so view that for more information.
     def upload!(from, to)
-      execute do |ssh|
-        scp = Net::SCP.new(ssh)
-        scp.upload!(from, to)
+      tries = 5
+
+      begin
+        execute do |ssh|
+          scp = Net::SCP.new(ssh.session)
+          scp.upload!(from, to)
+        end
+      rescue IOError
+        retry if (tries -= 1) > 0
+        raise
       end
     end
 
@@ -87,12 +97,14 @@ module Vagrant
     # Checks the file permissions for the private key, resetting them
     # if needed, or on failure erroring.
     def check_key_permissions(key_path)
+      return if Mario::Platform.windows?
+
       # TODO: This only works on unix based systems for now. Windows
       # systems will need to be investigated further.
       stat = File.stat(key_path)
 
       if stat.owned? && file_perms(key_path) != "600"
-        logger.info "Permissions on private key incorrect, fixing..."
+        env.logger.info "Permissions on private key incorrect, fixing..."
         File.chmod(0600, key_path)
 
         error_and_exit(:ssh_bad_permissions, :key_path => key_path) if file_perms(key_path) != "600"
@@ -112,9 +124,98 @@ module Vagrant
 
     # Returns the port which is either given in the options hash or taken from
     # the config by finding it in the forwarded ports hash based on the
-    # `config.ssh.forwarded_port_key`
+    # `config.ssh.forwarded_port_key` or use the default port given by `config.ssh.port`
+    # when port forwarding isn't used.
     def port(opts={})
-      opts[:port] || env.config.vm.forwarded_ports[env.config.ssh.forwarded_port_key][:hostport]
+      # Check if port was specified in options hash
+      pnum = opts[:port]
+      return pnum if pnum
+
+      # Check if we have an SSH forwarded port
+      pnum = env.vm.vm.forwarded_ports.detect do |fp|
+        fp.name == env.config.ssh.forwarded_port_key
+      end
+
+      return pnum.hostport if pnum
+
+      # Fall back to the default
+      return env.config.ssh.port
+    end
+  end
+
+  class SSH
+    # A helper class which wraps around `Net::SSH::Connection::Session`
+    # in order to provide basic command error checking while still
+    # providing access to the actual session object.
+    class Session
+      attr_reader :session
+
+      def initialize(session)
+        @session = session
+      end
+
+      # Executes a given command on the SSH session and blocks until
+      # the command completes. This is an almost line for line copy of
+      # the actual `exec!` implementation, except that this
+      # implementation also reports `:exit_status` to the block if given.
+      def exec!(command, options=nil, &block)
+        options = {
+          :error_check => true
+        }.merge(options || {})
+
+        block ||= Proc.new do |ch, type, data|
+          check_exit_status(data, command, options) if type == :exit_status && options[:error_check]
+
+          ch[:result] ||= ""
+          ch[:result] << data if [:stdout, :stderr].include?(type)
+        end
+
+        tries = 5
+
+        begin
+          metach = session.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise "could not execute command: #{command.inspect}" unless success
+
+              # Output stdout data to the block
+              channel.on_data do |ch2, data|
+                block.call(ch2, :stdout, data)
+              end
+
+              # Output stderr data to the block
+              channel.on_extended_data do |ch2, type, data|
+                block.call(ch2, :stderr, data)
+              end
+
+              # Output exit status information to the block
+              channel.on_request("exit-status") do |ch2, data|
+                block.call(ch2, :exit_status, data.read_long)
+              end
+            end
+          end
+        rescue IOError
+          retry if (tries -= 1) > 0
+          raise
+        end
+
+        metach.wait
+        metach[:result]
+      end
+
+      # Checks for an erroroneous exit status and raises an exception
+      # if so.
+      def check_exit_status(exit_status, command, options=nil)
+        if exit_status != 0
+          options = {
+            :error_key => :ssh_bad_exit_status,
+            :error_data => {
+              :command => command
+            }
+          }.merge(options || {})
+
+          raise Actions::ActionException.new(options[:error_key], options[:error_data])
+        end
+      end
     end
   end
 end

data/lib/vagrant/systems/base.rb

@@ -0,0 +1,70 @@
+module Vagrant
+  module Systems
+    # The base class for a "system." A system represents an installed
+    # operating system on a given box. There are some portions of
+    # Vagrant which are fairly OS-specific (such as mounting shared
+    # folders) and while the number is few, this abstraction allows
+    # more obscure operating systems to be installed without having
+    # to directly modify Vagrant internals.
+    #
+    # Subclasses of the system base class are expected to implement
+    # all the methods. These methods are described in the comments
+    # above their definition.
+    #
+    # **This is by no means a complete specification. The methods
+    # required by systems can and will change at any time. Any
+    # changes will be noted on release notes.**
+    class Base
+      include Vagrant::Util
+
+      # The VM which this system is tied to.
+      attr_reader :vm
+
+      # Initializes the system. Any subclasses MUST make sure this
+      # method is called on the parent. Therefore, if a subclass overrides
+      # `initialize`, then you must call `super`.
+      def initialize(vm)
+        @vm = vm
+      end
+
+      # A convenience method to access the logger on the VM
+      # environment.
+      def logger
+        vm.env.logger
+      end
+
+      # Halt the machine. This method should gracefully shut down the
+      # operating system. This method will cause `vagrant halt` and associated
+      # commands to _block_, meaning that if the machine doesn't halt
+      # in a reasonable amount of time, this method should just return.
+      #
+      # If when this method returns, the machine's state isn't "powered_off,"
+      # Vagrant will proceed to forcefully shut the machine down.
+      def halt; end
+
+      # Mounts a shared folder. This method is called by the shared
+      # folder action with an open SSH session (passed in as `ssh`).
+      # This method should create, mount, and properly set permissions
+      # on the shared folder. This method should also properly
+      # adhere to any configuration values such as `shared_folder_uid`
+      # on `config.vm`.
+      #
+      # @param [Object] ssh The Net::SSH session.
+      # @param [String] name The name of the shared folder.
+      # @param [String] guestpath The path on the machine which the user
+      #   wants the folder mounted.
+      def mount_shared_folder(ssh, name, guestpath); end
+
+      # Prepares the system for host only networks. This is called
+      # once prior to any `enable_host_only_network` calls.
+      def prepare_host_only_network; end
+
+      # Setup the system by adding a new host only network. This
+      # method should configure and bring up the interface for the
+      # given options.
+      #
+      # @param [Hash] net_options The options for the network.
+      def enable_host_only_network(net_options); end
+    end
+  end
+end

data/lib/vagrant/systems/linux.rb

@@ -0,0 +1,137 @@
+module Vagrant
+  module Systems
+    # A general Vagrant system implementation for "linux." In general,
+    # any linux-based OS will work fine with this system, although its
+    # not tested exhaustively. BSD or other based systems may work as
+    # well, but that hasn't been tested at all.
+    #
+    # At any rate, this system implementation should server as an
+    # example of how to implement any custom systems necessary.
+    class Linux < Base
+      # A custom config class which will be made accessible via `config.linux`
+      # This is not necessary for all system implementers, of course. However,
+      # generally, Vagrant tries to make almost every aspect of its execution
+      # configurable, and this assists that goal.
+      class LinuxConfig < Vagrant::Config::Base
+        attr_accessor :halt_timeout
+        attr_accessor :halt_check_interval
+
+        def initialize
+          @halt_timeout = 15
+          @halt_check_interval = 1
+        end
+      end
+
+      # Register config class
+      Config.configures :linux, LinuxConfig
+
+      #-------------------------------------------------------------------
+      # Overridden methods
+      #-------------------------------------------------------------------
+      def halt
+        logger.info "Attempting graceful shutdown of linux..."
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo halt")
+        end
+
+        # Wait until the VM's state is actually powered off. If this doesn't
+        # occur within a reasonable amount of time (15 seconds by default),
+        # then simply return and allow Vagrant to kill the machine.
+        count = 0
+        while vm.vm.state != :powered_off
+          count += 1
+
+          return if count >= vm.env.config.linux.halt_timeout
+          sleep vm.env.config.linux.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(ssh, name, guestpath)
+        ssh.exec!("sudo mkdir -p #{guestpath}")
+        mount_folder(ssh, name, guestpath)
+        chown(ssh, guestpath)
+      end
+
+      def create_sync(ssh, opts)
+        crontab_entry = render_crontab_entry(opts.merge(:syncopts => config.vm.sync_opts,
+                                                        :scriptname => config.vm.sync_script))
+
+        ssh.exec!("sudo mkdir -p #{opts[:syncpath]}")
+        chown(ssh, opts[:syncpath])
+        ssh.exec!("sudo echo \"#{crontab_entry}\" >> #{config.vm.sync_crontab_entry_file}")
+        ssh.exec!("crontab #{config.vm.sync_crontab_entry_file}")
+      end
+
+      def prepare_sync(ssh)
+        logger.info "Preparing system for sync..."
+        vm.ssh.upload!(StringIO.new(render_sync), config.vm.sync_script)
+        ssh.exec!("sudo chmod +x #{config.vm.sync_script}")
+        ssh.exec!("sudo rm #{config.vm.sync_crontab_entry_file}", :error_check => false)
+      end
+
+      def prepare_host_only_network
+        # Remove any previous host only network additions to the
+        # interface file.
+        vm.ssh.execute do |ssh|
+          # Verify debian/ubuntu
+          ssh.exec!("cat /etc/debian_version", :error_key => :network_not_debian)
+
+          # Clear out any previous entries
+          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-interfaces > /etc/network/interfaces'")
+        end
+      end
+
+      def enable_host_only_network(net_options)
+        entry = TemplateRenderer.render('network_entry', :net_options => net_options)
+        vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
+
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-entry >> /etc/network/interfaces'")
+          ssh.exec!("sudo /etc/init.d/networking restart")
+        end
+      end
+
+      #-------------------------------------------------------------------
+      # "Private" methods which assist above methods
+      #-------------------------------------------------------------------
+      def mount_folder(ssh, name, guestpath, sleeptime=5)
+        # Determine the permission string to attach to the mount command
+        perms = []
+        perms << "uid=#{vm.env.config.vm.shared_folder_uid}"
+        perms << "gid=#{vm.env.config.vm.shared_folder_gid}"
+        perms = " -o #{perms.join(",")}" if !perms.empty?
+
+        attempts = 0
+        while true
+          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
+
+          break unless result
+
+          attempts += 1
+          raise Actions::ActionException.new(:vm_mount_fail) if attempts >= 10
+          sleep sleeptime
+        end
+      end
+
+      def chown(ssh, dir)
+        ssh.exec!("sudo chown #{config.ssh.username} #{dir}")
+      end
+
+      def config
+        vm.env.config
+      end
+
+      def render_sync
+        TemplateRenderer.render('sync')
+      end
+
+      def render_crontab_entry(opts)
+        TemplateRenderer.render('crontab_entry', opts)
+      end
+    end
+  end
+end