tnargav 1.3.5 → 1.3.6

data/lib/vagrant/util/network_ip.rb

@@ -0,0 +1,28 @@
+module Vagrant
+  module Util
+    module NetworkIP
+      # Returns the network address of the given IP and subnet.
+      #
+      # @return [String]
+      def network_address(ip, subnet)
+        ip      = ip_parts(ip)
+        netmask = ip_parts(subnet)
+
+        # Bitwise-AND each octet to get the network address
+        # in octets and join each part with a period to get
+        # the resulting network address.
+        ip.map { |part| part & netmask.shift }.join(".")
+      end
+
+      protected
+
+      # Splits an IP into the four octets and returns each as an
+      # integer in an array.
+      #
+      # @return [Array<Integer>]
+      def ip_parts(ip)
+        ip.split(".").map { |i| i.to_i }
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -0,0 +1,101 @@
+require 'rbconfig'
+require 'tmpdir'
+
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def cygwin?
+          return true if ENV["VAGRANT_DETECTED_OS"] &&
+            ENV["VAGRANT_DETECTED_OS"].downcase.include?("cygwin")
+
+          platform.include?("cygwin")
+        end
+
+        [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
+          define_method("#{type}?") do
+            platform.include?(type.to_s)
+          end
+        end
+
+        def windows?
+          %W[mingw mswin].each do |text|
+            return true if platform.include?(text)
+          end
+
+          false
+        end
+
+        # This takes any path and converts it to a full-length Windows
+        # path on Windows machines in Cygwin.
+        #
+        # @return [String]
+        def cygwin_windows_path(path)
+          return path if !cygwin?
+
+          process = Subprocess.execute("cygpath", "-w", "-l", "-a", path.to_s)
+          process.stdout.chomp
+        end
+
+        # This checks if the filesystem is case sensitive. This is not a
+        # 100% correct check, since it is possible that the temporary
+        # directory runs a different filesystem than the root directory.
+        # However, this works in many cases.
+        def fs_case_sensitive?
+          tmp_dir = Dir.mktmpdir("vagrant")
+          tmp_file = File.join(tmp_dir, "FILE")
+          File.open(tmp_file, "w") do |f|
+            f.write("foo")
+          end
+
+          # The filesystem is case sensitive if the lowercased version
+          # of the filename is NOT reported as existing.
+          return !File.file?(File.join(tmp_dir, "file"))
+        end
+
+        # This expands the path and ensures proper casing of each part
+        # of the path.
+        def fs_real_path(path)
+          path = Pathname.new(File.expand_path(path))
+          raise "Path must exist for path expansion" if !path.exist?
+          return path if fs_case_sensitive?
+
+          # Build up all the parts of the path
+          original = []
+          while !path.root?
+            original.unshift(path.basename.to_s)
+            path = path.parent
+          end
+
+          # Traverse each part and join it into the resulting path
+          original.each do |single|
+            Dir.entries(path).each do |entry|
+              if entry.downcase == single.downcase
+                path = path.join(entry)
+              end
+            end
+          end
+
+          path
+        end
+
+        # Returns a boolean noting whether the terminal supports color.
+        # output.
+        def terminal_supports_colors?
+          if windows?
+            return ENV.has_key?("ANSICON") || cygwin?
+          end
+
+          true
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/retryable.rb

@@ -0,0 +1,31 @@
+require "log4r"
+
+module Vagrant
+  module Util
+    module Retryable
+      # Retries a given block a specified number of times in the
+      # event the specified exception is raised. If the retries
+      # run out, the final exception is raised.
+      #
+      # This code is adapted slightly from the following blog post:
+      # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+      def retryable(opts=nil)
+        logger = nil
+        opts   = { :tries => 1, :on => Exception }.merge(opts || {})
+
+        begin
+          return yield
+        rescue *opts[:on] => e
+          if (opts[:tries] -= 1) > 0
+            logger = Log4r::Logger.new("vagrant::util::retryable")
+            logger.info("Retryable exception raised: #{e.inspect}")
+
+            sleep opts[:sleep].to_f if opts[:sleep]
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_chdir.rb

@@ -0,0 +1,33 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    class SafeChdir
+      @@chdir_lock  = Mutex.new
+
+      # Safely changes directory of this process by putting a lock around
+      # it so that it is thread safe. This will yield a block and when the
+      # block exits it changes back to the original directory.
+      #
+      # @param [String] dir Dir to change to temporarily
+      def self.safe_chdir(dir)
+        lock = @@chdir_lock
+
+        begin
+          @@chdir_lock.synchronize {}
+        rescue ThreadError
+          # If we already hold the lock, just create a new lock so we
+          # definitely don't block and don't get an error.
+          lock = Mutex.new
+        end
+
+        lock.synchronize do
+          Dir.chdir(dir) do
+            return yield
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/util/safe_exec.rb

@@ -0,0 +1,36 @@
+module Vagrant
+  module Util
+    # This module provies a `safe_exec` method which is a drop-in
+    # replacement for `Kernel.exec` which addresses a specific issue
+    # which manifests on OS X 10.5 (GH-51) and perhaps other operating systems.
+    # This issue causes `exec` to fail if there is more than one system
+    # thread. In that case, `safe_exec` automatically falls back to
+    # forking.
+    class SafeExec
+      def self.exec(command, *args)
+        # Create a list of things to rescue from. Since this is OS
+        # specific, we need to do some defined? checks here to make
+        # sure they exist.
+        rescue_from = []
+        rescue_from << Errno::EOPNOTSUPP if defined?(Errno::EOPNOTSUPP)
+        rescue_from << Errno::E045 if defined?(Errno::E045)
+        rescue_from << SystemCallError
+
+        fork_instead = false
+        begin
+          pid = nil
+          pid = fork if fork_instead
+          Kernel.exec(command, *args) if pid.nil?
+          Process.wait(pid) if pid
+        rescue *rescue_from
+          # We retried already, raise the issue and be done
+          raise if fork_instead
+
+          # The error manifested itself, retry with a fork.
+          fork_instead = true
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/safe_puts.rb

@@ -0,0 +1,31 @@
+module Vagrant
+  module Util
+    # This module provides a `safe_puts` method which outputs to
+    # the given IO object, and rescues any broken pipe errors and
+    # ignores them. This is useful in cases where you're outputting
+    # to stdout, for example, and the stdout is closed, but you want to
+    # keep running.
+    module SafePuts
+      # Uses `puts` on the given IO object and safely ignores any
+      # Errno::EPIPE.
+      #
+      # @param [String] message Message to output.
+      # @param [Hash] opts Options hash.
+      def safe_puts(message=nil, opts=nil)
+        message ||= ""
+        opts = {
+          :io => $stdout,
+          :printer => :puts
+        }.merge(opts || {})
+
+        begin
+          opts[:io].send(opts[:printer], message)
+        rescue Errno::EPIPE
+          # This is what makes this a `safe` puts.
+          return
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/util/scoped_hash_override.rb

@@ -0,0 +1,45 @@
+module Vagrant
+  module Util
+    # This allows for hash options to be overridden by a scope key
+    # prefix. An example speaks best here. Imagine the following hash:
+    #
+    #     original = {
+    #       :id => "foo",
+    #       :mitchellh__id => "bar",
+    #       :mitchellh__other => "foo"
+    #     }
+    #
+    #     scoped = scoped_hash_override(original, "mitchellh")
+    #
+    #     scoped == {
+    #       :id => "bar",
+    #       :other => "foo"
+    #     }
+    #
+    module ScopedHashOverride
+      def scoped_hash_override(original, scope)
+        # Convert the scope to a string in case a symbol was given since
+        # we use string comparisons for everything.
+        scope = scope.to_s
+
+        # Shallow copy the hash for the result
+        result = original.dup
+
+        original.each do |key, value|
+          parts = key.to_s.split("__", 2)
+
+          # If we don't have the proper parts, then bail
+          next if parts.length != 2
+
+          # If this is our scope, then override
+          if parts[0] == scope
+            result[parts[1].to_sym] = value
+            result.delete(key)
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/vagrant/util/ssh.rb

@@ -0,0 +1,155 @@
+require "log4r"
+
+require "vagrant/util/file_mode"
+require "vagrant/util/platform"
+require "vagrant/util/safe_exec"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module Vagrant
+  module Util
+    # This is a class that has helpers on it for dealing with SSH. These
+    # helpers don't depend on any part of Vagrant except what is given
+    # via the parameters.
+    class SSH
+      LOGGER = Log4r::Logger.new("vagrant::util::ssh")
+
+      # Checks that the permissions for a private key are valid, and fixes
+      # them if possible. SSH requires that permissions on the private key
+      # are 0600 on POSIX based systems. This will make a best effort to
+      # fix these permissions if they are not properly set.
+      #
+      # @param [Pathname] key_path The path to the private key.
+      def self.check_key_permissions(key_path)
+        # Don't do anything if we're on Windows, since Windows doesn't worry
+        # about key permissions.
+        return if Platform.windows?
+
+        LOGGER.debug("Checking key permissions: #{key_path}")
+        stat = key_path.stat
+
+        if !stat.owned?
+          # The SSH key must be owned by ourselves
+          raise Errors::SSHKeyBadOwner, :key_path => key_path
+        end
+
+        if FileMode.from_octal(stat.mode) != "600"
+          LOGGER.info("Attempting to correct key permissions to 0600")
+          key_path.chmod(0600)
+
+          # Re-stat the file to get the new mode, and verify it worked
+          stat = key_path.stat
+          if FileMode.from_octal(stat.mode) != "600"
+            raise Errors::SSHKeyBadPermissions, :key_path => key_path
+          end
+        end
+      rescue Errno::EPERM
+        # This shouldn't happen since we verify we own the file, but
+        # it is possible in theory, so we raise an error.
+        raise Errors::SSHKeyBadPermissions, :key_path => key_path
+      end
+
+      # Halts the running of this process and replaces it with a full-fledged
+      # SSH shell into a remote machine.
+      #
+      # Note: This method NEVER returns. The process ends after this.
+      #
+      # @param [Hash] ssh_info This is the SSH information. For the keys
+      #   required please see the documentation of {Machine#ssh_info}.
+      # @param [Hash] opts These are additional options that are supported
+      #   by exec.
+      def self.exec(ssh_info, opts={})
+        # Ensure the platform supports ssh. On Windows there are several programs which
+        # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
+        ssh_path = Which.which("ssh")
+        if !ssh_path
+          if Platform.windows?
+            raise Errors::SSHUnavailableWindows,
+              :host => ssh_info[:host],
+              :port => ssh_info[:port],
+              :username => ssh_info[:username],
+              :key_path => ssh_info[:private_key_path]
+          end
+
+          raise Errors::SSHUnavailable
+        end
+
+        # On Windows, we need to detect whether SSH is actually "plink"
+        # underneath the covers. In this case, we tell the user.
+        if Platform.windows?
+          r = Subprocess.execute(ssh_path)
+          if r.stdout.include?("PuTTY Link")
+            raise Errors::SSHIsPuttyLink,
+              :host => ssh_info[:host],
+              :port => ssh_info[:port],
+              :username => ssh_info[:username],
+              :key_path => ssh_info[:private_key_path]
+          end
+        end
+
+        # If plain mode is enabled then we don't do any authentication (we don't
+        # set a user or an identity file)
+        plain_mode = opts[:plain_mode]
+
+        options = {}
+        options[:host] = ssh_info[:host]
+        options[:port] = ssh_info[:port]
+        options[:username] = ssh_info[:username]
+        options[:private_key_path] = ssh_info[:private_key_path]
+
+        # Command line options
+        command_options = [
+          "-p", options[:port].to_s,
+          "-o", "DSAAuthentication=yes",
+          "-o", "LogLevel=FATAL",
+          "-o", "StrictHostKeyChecking=no",
+          "-o", "UserKnownHostsFile=/dev/null"]
+
+        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
+        # IdentitiesOnly option. Also, we don't enable it in plain mode so
+        # that SSH properly searches our identities and tries to do it itself.
+        if !Platform.solaris? && !plain_mode
+          command_options += ["-o", "IdentitiesOnly=yes"]
+        end
+
+        # If we're not in plain mode, attach the private key path.
+        command_options += ["-i", options[:private_key_path].to_s] if !plain_mode
+
+        if ssh_info[:forward_x11]
+          # Both are required so that no warnings are shown regarding X11
+          command_options += [
+            "-o", "ForwardX11=yes",
+            "-o", "ForwardX11Trusted=yes"]
+        end
+
+        if ssh_info[:proxy_command]
+          command_options += ["-o", "ProxyCommand=#{ssh_info[:proxy_command]}"]
+        end
+
+        # Configurables -- extra_args should always be last due to the way the
+        # ssh args parser works. e.g. if the user wants to use the -t option,
+        # any shell command(s) she'd like to run on the remote server would
+        # have to be the last part of the 'ssh' command:
+        #
+        #   $ ssh localhost -t -p 2222 "cd mydirectory; bash"
+        #
+        # Without having extra_args be last, the user loses this ability
+        command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
+        command_options.concat(opts[:extra_args]) if opts[:extra_args]
+
+        # Build up the host string for connecting
+        host_string = options[:host]
+        host_string = "#{options[:username]}@#{host_string}" if !plain_mode
+        command_options.unshift(host_string)
+
+        # On Cygwin we want to get rid of any DOS file warnings because
+        # we really don't care since both work.
+        ENV["nodosfilewarning"] = "1" if Platform.cygwin?
+
+        # Invoke SSH with all our options
+        LOGGER.info("Invoking SSH: #{command_options.inspect}")
+        SafeExec.exec("ssh", *command_options)
+      end
+    end
+  end
+end