vagrant-fixed-ssh 1.0.7

data/lib/vagrant/config/vm/provisioner.rb

@@ -0,0 +1,52 @@
+require 'log4r'
+
+module Vagrant
+  module Config
+    class VMConfig < Base
+      # Represents a single configured provisioner for a VM.
+      class Provisioner
+        attr_reader :shortcut
+        attr_reader :provisioner
+        attr_reader :config
+
+        def initialize(shortcut, options=nil, &block)
+          @logger = Log4r::Logger.new("vagrant::config::vm::provisioner")
+          @logger.debug("Provisioner config: #{shortcut}")
+          @shortcut = shortcut
+          @provisioner = shortcut
+          @provisioner = Vagrant.provisioners.get(shortcut) if shortcut.is_a?(Symbol)
+          @config = nil
+
+          @logger.info("Provisioner class: #{provisioner}")
+          configure(options, &block) if @provisioner
+        end
+
+        # Configures the provisioner if it can (if it is valid).
+        def configure(options=nil, &block)
+          config_class = @provisioner.config_class
+          return if !config_class
+
+          @logger.debug("Configuring provisioner with: #{config_class}")
+          @config = config_class.new
+          @config.set_options(options) if options
+          block.call(@config) if block
+        end
+
+        def validate(env, errors)
+          if !provisioner
+            # If we don't have a provisioner then the whole thing is invalid.
+            errors.add(I18n.t("vagrant.config.vm.provisioner_not_found", :shortcut => shortcut))
+            return
+          end
+
+          if !(provisioner <= Provisioners::Base)
+            errors.add(I18n.t("vagrant.config.vm.provisioner_invalid_class", :shortcut => shortcut))
+          end
+
+          # Pass on validation to the provisioner config
+          config.validate(env, errors) if config
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/vm/sub_vm.rb

@@ -0,0 +1,17 @@
+module Vagrant
+  module Config
+    class VMConfig < Base
+      # Represents a single sub-VM in a multi-VM environment.
+      class SubVM
+        include Util::StackedProcRunner
+
+        attr_reader :options
+
+        def initialize
+          @options = {}
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/data_store.rb

@@ -0,0 +1,92 @@
+require 'pathname'
+
+require 'log4r'
+
+module Vagrant
+  # The Vagrant data store is a key-value store which is persisted
+  # as JSON in a local file which is specified in the initializer.
+  # The data store itself is accessed via typical hash accessors: `[]`
+  # and `[]=`. If a key is set to `nil`, then it is removed from the
+  # datastore. The data store is only updated on disk when {#commit}
+  # is called on the data store itself.
+  #
+  # The data store is a hash with indifferent access, meaning that
+  # while all keys are persisted as strings in the JSON, you can access
+  # them back as either symbols or strings. Note that this is only true
+  # for the top-level data store. As soon as you set a hash inside the
+  # data store, unless you explicitly use a {Util::HashWithIndifferentAccess},
+  # it will be a regular hash.
+  class DataStore < Util::HashWithIndifferentAccess
+    attr_reader :file_path
+
+    def initialize(file_path)
+      @logger    = Log4r::Logger.new("vagrant::datastore")
+
+      if file_path
+        @logger.info("Created: #{file_path}")
+
+        @file_path = Pathname.new(file_path)
+        if @file_path.exist?
+          raise Errors::DotfileIsDirectory if @file_path.directory?
+
+          begin
+            merge!(JSON.parse(@file_path.read))
+          rescue JSON::ParserError
+            # Ignore if the data is invalid in the file.
+            @logger.error("Data store contained invalid JSON. Ignoring.")
+          end
+        end
+      else
+        @logger.info("No file path. In-memory data store.")
+        @file_path = nil
+      end
+    end
+
+    # Commits any changes to the data to disk. Even if the data
+    # hasn't changed, it will be reserialized and written to disk.
+    def commit
+      if !@file_path
+        raise StandardError, "In-memory data stores can't be committed."
+      end
+
+      clean_nil_and_empties
+
+      if empty?
+        # Delete the file since an empty data store is not useful
+        @logger.info("Deleting data store since we're empty: #{@file_path}")
+        @file_path.delete if @file_path.exist?
+      else
+        @logger.info("Committing data to data store: #{@file_path}")
+
+        @file_path.open("w") do |f|
+          f.write(to_json)
+          f.fsync
+        end
+      end
+    end
+
+    protected
+
+    # Removes the "nil" and "empty?" values from the hash (children
+    # included) so that the final output JSON is cleaner.
+    def clean_nil_and_empties(hash=self)
+      # Clean depth first
+      hash.each do |k, v|
+        clean_nil_and_empties(v) if v.is_a?(Hash)
+      end
+
+      # Clean ourselves, knowing that any children have already been
+      # cleaned up
+      bad_keys = hash.inject([]) do |acc, data|
+        k,v = data
+        acc.push(k) if v.nil?
+        acc.push(k) if v.respond_to?(:empty?) && v.empty?
+        acc
+      end
+
+      bad_keys.each do |key|
+        hash.delete(key)
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Downloaders
+    autoload :Base, 'vagrant/downloaders/base'
+    autoload :File, 'vagrant/downloaders/file'
+    autoload :HTTP, 'vagrant/downloaders/http'
+  end
+end

data/lib/vagrant/downloaders/base.rb

@@ -0,0 +1,25 @@
+module Vagrant
+  module Downloaders
+    # Represents a base class for a downloader. A downloader handles
+    # downloading a box file to a temporary file.
+    class Base
+      include Vagrant::Util
+
+      def initialize(ui)
+        @ui = ui
+      end
+
+      # Tests whether a URL matches this download. Subclasses must
+      # override this and return `true` for any URLs they wish to
+      # handle.
+      def self.match?(url); false; end
+
+      # Called prior to execution so any error checks can be done
+      def prepare(source_url); end
+
+      # Downloads the source file to the destination file. It is up to
+      # implementors of this class to handle the logic.
+      def download!(source_url, destination_file); end
+    end
+  end
+end

data/lib/vagrant/downloaders/file.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+
+module Vagrant
+  module Downloaders
+    # "Downloads" a file to a temporary file. Basically, this downloader
+    # simply does a file copy.
+    class File < Base
+      def self.match?(uri)
+        ::File.file?(::File.expand_path(uri))
+      end
+
+      def prepare(source_url)
+        raise Errors::DownloaderFileDoesntExist if !::File.file?(::File.expand_path(source_url))
+      end
+
+      def download!(source_url, destination_file)
+        @ui.info I18n.t("vagrant.downloaders.file.download")
+        FileUtils.cp(::File.expand_path(source_url), destination_file.path)
+      end
+    end
+  end
+end

data/lib/vagrant/downloaders/http.rb

@@ -0,0 +1,97 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'base64'
+
+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
+      def self.match?(uri)
+        # URI.parse barfs on '<drive letter>:\\files \on\ windows'
+        extracted = URI.extract(uri).first
+        extracted && extracted.include?(uri)
+      end
+
+      def download!(source_url, destination_file)
+        uri = URI.parse(source_url)
+        proxy_uri = resolve_proxy(uri)
+
+        http = Net::HTTP.new(uri.host, uri.port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+        http.read_timeout = nil # Disable the read timeout, just let it try to download
+
+        if uri.scheme == "https"
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        http.start do |h|
+          @ui.info I18n.t("vagrant.downloaders.http.download", :url => source_url)
+
+          headers = nil
+          if uri.user && uri.password
+            headers = {'Authorization' => 'Basic ' + Base64.encode64(uri.user + ':' + uri.password)}
+          end
+
+          h.request_get(uri.request_uri, headers) do |response|
+            if response.is_a?(Net::HTTPRedirection)
+              # Follow the HTTP redirect.
+              # TODO: Error on some redirect limit
+              download!(response["Location"], destination_file)
+              return
+            elsif !response.is_a?(Net::HTTPOK)
+              raise Errors::DownloaderHTTPStatusError, :status => response.code
+            end
+
+            total = response.content_length
+            progress = 0
+            segment_count = 0
+
+            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
+                @ui.clear_line
+                @ui.report_progress(progress, total)
+                segment_count = 0
+              end
+
+              # Store the segment
+              destination_file.write(segment)
+            end
+
+            # Clear the line one last time so that the progress meter disappears
+            @ui.clear_line
+          end
+        end
+      rescue SocketError
+        raise Errors::DownloaderHTTPSocketError
+      end
+
+      private
+
+      # This method respects the "http_proxy" and "no_proxy" environmental
+      # variables so that HTTP proxies can properly be used with Vagrant.
+      def resolve_proxy(source_uri)
+        proxy_string = ENV["http_proxy"] || ""
+        if !proxy_string.empty? && ENV.has_key?("no_proxy")
+          # Respect the "no_proxy" environmental variable which contains a list
+          # of hosts that a proxy should not be used for.
+          ENV["no_proxy"].split(",").each do |host|
+            if source_uri.host =~ /#{Regexp.quote(host.strip)}$/
+              proxy_string = ""
+              break
+            end
+          end
+        end
+
+        URI.parse(proxy_string)
+      end
+    end
+  end
+end

data/lib/vagrant/driver.rb

@@ -0,0 +1,8 @@
+module Vagrant
+  module Driver
+    autoload :VirtualBox, 'vagrant/driver/virtualbox'
+    autoload :VirtualBox_4_0, 'vagrant/driver/virtualbox_4_0'
+    autoload :VirtualBox_4_1, 'vagrant/driver/virtualbox_4_1'
+    autoload :VirtualBox_4_2, 'vagrant/driver/virtualbox_4_2'
+  end
+end

data/lib/vagrant/driver/virtualbox.rb

@@ -0,0 +1,134 @@
+require 'forwardable'
+
+require 'log4r'
+
+require 'vagrant/driver/virtualbox_base'
+
+module Vagrant
+  module Driver
+    # This class contains the logic to drive VirtualBox.
+    #
+    # Read the VirtualBoxBase source for documentation on each method.
+    class VirtualBox < VirtualBoxBase
+      # This is raised if the VM is not found when initializing a driver
+      # with a UUID.
+      class VMNotFound < StandardError; end
+
+      # We use forwardable to do all our driver forwarding
+      extend Forwardable
+
+      # The UUID of the virtual machine we represent
+      attr_reader :uuid
+
+      # The version of virtualbox that is running.
+      attr_reader :version
+
+      def initialize(uuid=nil)
+        # Setup the base
+        super()
+
+        @logger = Log4r::Logger.new("vagrant::driver::virtualbox")
+        @uuid = uuid
+
+        # Read and assign the version of VirtualBox we know which
+        # specific driver to instantiate.
+        begin
+          @version = read_version || ""
+        rescue Subprocess::LaunchError
+          # This means that VirtualBox was not found, so we raise this
+          # error here.
+          raise Errors::VirtualBoxNotDetected
+        end
+
+        # Instantiate the proper version driver for VirtualBox
+        @logger.debug("Finding driver for VirtualBox version: #{@version}")
+        driver_map   = {
+          "4.0" => VirtualBox_4_0,
+          "4.1" => VirtualBox_4_1,
+          "4.2" => VirtualBox_4_2
+        }
+
+        driver_klass = nil
+        driver_map.each do |key, klass|
+          if @version.start_with?(key)
+            driver_klass = klass
+            break
+          end
+        end
+
+        if !driver_klass
+          supported_versions = driver_map.keys.sort.join(", ")
+          raise Errors::VirtualBoxInvalidVersion, :supported_versions => supported_versions
+        end
+
+        @logger.info("Using VirtualBox driver: #{driver_klass}")
+        @driver = driver_klass.new(@uuid)
+
+        if @uuid
+          # Verify the VM exists, and if it doesn't, then don't worry
+          # about it (mark the UUID as nil)
+          raise VMNotFound if !@driver.vm_exists?(@uuid)
+        end
+      end
+
+      def_delegators :@driver, :clear_forwarded_ports,
+                               :clear_shared_folders,
+                               :create_dhcp_server,
+                               :create_host_only_network,
+                               :delete,
+                               :delete_unused_host_only_networks,
+                               :discard_saved_state,
+                               :enable_adapters,
+                               :execute_command,
+                               :export,
+                               :forward_ports,
+                               :halt,
+                               :import,
+                               :read_forwarded_ports,
+                               :read_bridged_interfaces,
+                               :read_guest_additions_version,
+                               :read_host_only_interfaces,
+                               :read_mac_address,
+                               :read_machine_folder,
+                               :read_network_interfaces,
+                               :read_state,
+                               :read_used_ports,
+                               :read_vms,
+                               :set_mac_address,
+                               :set_name,
+                               :share_folders,
+                               :ssh_port,
+                               :start,
+                               :suspend,
+                               :verify!,
+                               :verify_image,
+                               :vm_exists?
+
+      protected
+
+      # This returns the version of VirtualBox that is running.
+      #
+      # @return [String]
+      def read_version
+        # The version string is usually in one of the following formats:
+        #
+        # * 4.1.8r1234
+        # * 4.1.8r1234_OSE
+        # * 4.1.8_MacPortsr1234
+        #
+        # Below accounts for all of these.
+
+        # Note: We split this into multiple lines because apparently "".split("_")
+        # is [], so we have to check for an empty array in between.
+        output = execute("--version")
+        if output =~ /vboxdrv kernel module is not loaded/
+          raise Errors::VirtualBoxKernelModuleNotLoaded
+        end
+
+        parts = output.split("_")
+        return nil if parts.empty?
+        parts[0].split("r")[0]
+      end
+    end
+  end
+end