vagrant 1.0.7 → 2.4.4

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

@@ -1,17 +0,0 @@
-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/config/vm.rb

@@ -1,168 +0,0 @@
-require 'pathname'
-
-require 'vagrant/config/vm/sub_vm'
-require 'vagrant/config/vm/provisioner'
-
-module Vagrant
-  module Config
-    class VMConfig < Base
-      attr_accessor :name
-      attr_accessor :auto_port_range
-      attr_accessor :box
-      attr_accessor :box_url
-      attr_accessor :base_mac
-      attr_accessor :boot_mode
-      attr_accessor :host_name
-      attr_reader :forwarded_ports
-      attr_reader :shared_folders
-      attr_reader :networks
-      attr_reader :provisioners
-      attr_reader :customizations
-      attr_accessor :guest
-
-      def initialize
-        @forwarded_ports = []
-        @shared_folders = {}
-        @networks = []
-        @provisioners = []
-        @customizations = []
-      end
-
-      # Custom merge method since some keys here are merged differently.
-      def merge(other)
-        result = super
-        result.instance_variable_set(:@forwarded_ports, @forwarded_ports + other.forwarded_ports)
-        result.instance_variable_set(:@shared_folders, @shared_folders.merge(other.shared_folders))
-        result.instance_variable_set(:@networks, @networks + other.networks)
-        result.instance_variable_set(:@provisioners, @provisioners + other.provisioners)
-        result.instance_variable_set(:@customizations, @customizations + other.customizations)
-        result
-      end
-
-      def forward_port(guestport, hostport, options=nil)
-        @forwarded_ports << {
-          :name       => "#{guestport.to_s(32)}-#{hostport.to_s(32)}",
-          :guestport  => guestport,
-          :hostport   => hostport,
-          :protocol   => :tcp,
-          :adapter    => 1,
-          :auto       => false
-        }.merge(options || {})
-      end
-
-      def share_folder(name, guestpath, hostpath, opts=nil)
-        @shared_folders[name] = {
-          :guestpath => guestpath.to_s,
-          :hostpath => hostpath.to_s,
-          :create => false,
-          :owner => nil,
-          :group => nil,
-          :nfs   => false,
-          :transient => false,
-          :extra => nil
-        }.merge(opts || {})
-      end
-
-      def network(type, *args)
-        @networks << [type, args]
-      end
-
-      def provision(name, options=nil, &block)
-        @provisioners << Provisioner.new(name, options, &block)
-      end
-
-      # TODO: This argument should not be `nil` in the future.
-      # It is only defaulted to nil so that the deprecation error
-      # can be properly shown.
-      def customize(command=nil)
-        @customizations << command if command
-      end
-
-      def defined_vms
-        @defined_vms ||= {}
-      end
-
-      # This returns the keys of the sub-vms in the order they were
-      # defined.
-      def defined_vm_keys
-        @defined_vm_keys ||= []
-      end
-
-      def define(name, options=nil, &block)
-        name = name.to_sym
-        options ||= {}
-
-        # Add the name to the array of VM keys. This array is used to
-        # preserve the order in which VMs are defined.
-        defined_vm_keys << name
-
-        # Add the SubVM to the hash of defined VMs
-        defined_vms[name] ||= SubVM.new
-        defined_vms[name].options.merge!(options)
-        defined_vms[name].push_proc(&block) if block
-      end
-
-      def validate(env, errors)
-        errors.add(I18n.t("vagrant.config.vm.box_missing")) if !box
-        errors.add(I18n.t("vagrant.config.vm.box_not_found", :name => box)) if box && !box_url && !env.boxes.find(box)
-        errors.add(I18n.t("vagrant.config.vm.boot_mode_invalid")) if ![:headless, :gui].include?(boot_mode.to_sym)
-        errors.add(I18n.t("vagrant.config.vm.base_mac_invalid")) if env.boxes.find(box) && !base_mac
-
-        shared_folders.each do |name, options|
-          hostpath = Pathname.new(options[:hostpath]).expand_path(env.root_path)
-
-          if !hostpath.directory? && !options[:create]
-            errors.add(I18n.t("vagrant.config.vm.shared_folder_hostpath_missing",
-                       :name => name,
-                       :path => options[:hostpath]))
-          end
-
-          if options[:nfs] && (options[:owner] || options[:group])
-            # Owner/group don't work with NFS
-            errors.add(I18n.t("vagrant.config.vm.shared_folder_nfs_owner_group",
-                              :name => name))
-          end
-        end
-
-        # Validate some basic networking
-        #
-        # TODO: One day we need to abstract this out, since in the future
-        # providers other than VirtualBox will not be able to satisfy
-        # all types of networks.
-        networks.each do |type, args|
-          if type == :hostonly && args[0] == :dhcp
-            # Valid. There is no real way this can be invalid at the moment.
-          elsif type == :hostonly
-            # Validate the host-only network
-            ip      = args[0]
-            options = args[1] || {}
-
-            if !ip
-              errors.add(I18n.t("vagrant.config.vm.network_ip_required"))
-            else
-              ip_parts = ip.split(".")
-
-              if ip_parts.length != 4
-                errors.add(I18n.t("vagrant.config.vm.network_ip_invalid",
-                                  :ip => ip))
-              elsif ip_parts.last == "1"
-                errors.add(I18n.t("vagrant.config.vm.network_ip_ends_one",
-                                  :ip => ip))
-              end
-            end
-          elsif type == :bridged
-          else
-            # Invalid network type
-            errors.add(I18n.t("vagrant.config.vm.network_invalid",
-                              :type => type.to_s))
-          end
-        end
-
-        # Each provisioner can validate itself
-        provisioners.each do |prov|
-          prov.validate(env, errors)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/data_store.rb

@@ -1,92 +0,0 @@
-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/base.rb

@@ -1,25 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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/downloaders.rb

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

data/lib/vagrant/driver/virtualbox.rb

@@ -1,134 +0,0 @@
-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