vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/lib/vagrant/util/file_mode.rb

@@ -1,12 +0,0 @@
-module Vagrant
-  module Util
-    class FileMode
-      # This returns the file permissions as a string from
-      # an octal number.
-      def self.from_octal(octal)
-        perms = sprintf("%o", octal)
-        perms.reverse[0..2].reverse
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/hash_with_indifferent_access.rb

@@ -1,63 +0,0 @@
-module Vagrant
-  module Util
-    # A hash with indifferent access. Mostly taken from Thor/Rails (thanks).
-    # Normally I'm not a fan of using an indifferent access hash since Symbols
-    # are basically memory leaks in Ruby, but since Vagrant is typically a quick
-    # one-off binary run and it doesn't use too many hash keys where this is
-    # used, the effect should be minimal.
-    #
-    #   hash[:foo]  #=> 'bar'
-    #   hash['foo'] #=> 'bar'
-    #
-    class HashWithIndifferentAccess < ::Hash
-      def initialize(hash={}, &block)
-        super(&block)
-
-        hash.each do |key, value|
-          self[convert_key(key)] = value
-        end
-      end
-
-      def [](key)
-        super(convert_key(key))
-      end
-
-      def []=(key, value)
-        super(convert_key(key), value)
-      end
-
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def values_at(*indices)
-        indices.collect { |key| self[convert_key(key)] }
-      end
-
-      def merge(other)
-        dup.merge!(other)
-      end
-
-      def merge!(other)
-        other.each do |key, value|
-          self[convert_key(key)] = value
-        end
-        self
-      end
-
-      def key?(key)
-        super(convert_key(key))
-      end
-
-      alias_method :include?, :key?
-      alias_method :has_key?, :key?
-      alias_method :member?, :key?
-
-      protected
-
-      def convert_key(key)
-        key.is_a?(Symbol) ? key.to_s : key
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/is_port_open.rb

@@ -1,38 +0,0 @@
-require "socket"
-require "timeout"
-
-module Vagrant
-  module Util
-    # Contains the method {#is_ruby_open?} to check if a port is open
-    # (listening) or closed (not in use). This method isn't completely
-    # fool-proof, but it works enough of the time to be useful.
-    module IsPortOpen
-      # Checks if a port is open (listening) on a given host and port.
-      #
-      # @param [String] host Hostname or IP address.
-      # @param [Integer] port Port to check.
-      # @return [Boolean] `true` if the port is open (listening), `false`
-      #   otherwise.
-      def is_port_open?(host, port)
-        # We wrap this in a timeout because once in awhile the TCPSocket
-        # _will_ hang, but this signals that the port is closed.
-        Timeout.timeout(1) do
-          # Attempt to make a connection
-          s = TCPSocket.new(host, port)
-
-          # A connection was made! Properly clean up the socket, not caring
-          # at all if any exception is raised, because we already know the
-          # result.
-          s.close rescue nil
-
-          # The port is open if we reached this point, since we were able
-          # to connect.
-          return true
-        end
-      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
-        # Any of the above exceptions signal that the port is closed.
-        return false
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/line_ending_helpers.rb

@@ -1,14 +0,0 @@
-module Vagrant
-  module Util
-    module LineEndingHelpers
-      # Converts line endings to unix-style line endings in the
-      # given string.
-      #
-      # @param [String] string Original string
-      # @return [String] The fixed string
-      def dos_to_unix(string)
-        string.gsub("\r\n", "\n")
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/network_ip.rb

@@ -1,28 +0,0 @@
-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/vendor/vagrant/lib/vagrant/util/platform.rb

@@ -1,68 +0,0 @@
-require 'rbconfig'
-require 'tempfile'
-
-module Vagrant
-  module Util
-    # This class just contains some platform checking code.
-    class Platform
-      class << self
-        def tiger?
-          platform.include?("darwin8")
-        end
-
-        def leopard?
-          platform.include?("darwin9")
-        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
-
-        # Returns boolean noting whether this is a 64-bit CPU. This
-        # is not 100% accurate and there could easily be false negatives.
-        #
-        # @return [Boolean]
-        def bit64?
-          ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
-        end
-
-        # Returns boolean noting whether this is a 32-bit CPU. This
-        # can easily throw false positives since it relies on {#bit64?}.
-        #
-        # @return [Boolean]
-        def bit32?
-          !bit64?
-        end
-
-        # Returns a boolean noting whether the terminal supports color.
-        # output.
-        def terminal_supports_colors?
-          if windows?
-            return ENV.has_key?("ANSICON")
-          end
-
-          true
-        end
-
-        def tar_file_options
-          # create, write only, fail if the file exists, binary if windows
-          File::WRONLY | File::EXCL | File::CREAT | (windows? ? File::BINARY : 0)
-        end
-
-        def platform
-          RbConfig::CONFIG["host_os"].downcase
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/util/retryable.rb

@@ -1,31 +0,0 @@
-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/vendor/vagrant/lib/vagrant/util/safe_exec.rb

@@ -1,36 +0,0 @@
-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/vendor/vagrant/lib/vagrant/util/safe_puts.rb

@@ -1,31 +0,0 @@
-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/vendor/vagrant/lib/vagrant/util/scoped_hash_override.rb

@@ -1,45 +0,0 @@
-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/vendor/vagrant/lib/vagrant/util/ssh.rb

@@ -1,126 +0,0 @@
-require "log4r"
-
-require "vagrant/util/file_mode"
-require "vagrant/util/platform"
-require "vagrant/util/safe_exec"
-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? && 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!
-        if !Which.which("ssh")
-          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
-
-        # 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", "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
-
-        # 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)
-
-        # Invoke SSH with all our options
-        LOGGER.info("Invoking SSH: #{command_options.inspect}")
-        SafeExec.exec("ssh", *command_options)
-      end
-    end
-  end
-end