vagrant-fixed-ssh 1.0.7

data/lib/vagrant/config/container.rb

@@ -0,0 +1,37 @@
+module Vagrant
+  module Config
+    # Contains loaded configuration values and provides access to those
+    # values.
+    #
+    # This is the class returned when loading configuration and stores
+    # the completely loaded configuration values. This class is meant to
+    # be immutable.
+    class Container
+      attr_reader :global
+      attr_reader :vms
+
+      # Initializes the configuration container.
+      #
+      # @param [Top] global Top-level configuration for the global
+      #   applicatoin.
+      # @param [Array] vms Array of VM configurations.
+      def initialize(global, vms)
+        @global = global
+        @vms    = []
+        @vm_configs = {}
+
+        vms.each do |vm_config|
+          @vms << vm_config.vm.name
+          @vm_configs[vm_config.vm.name] = vm_config
+        end
+      end
+
+      # This returns the configuration for a specific virtual machine.
+      # The values for this configuration are usually pertinent to a
+      # single virtual machine and do not affect the system globally.
+      def for_vm(name)
+        @vm_configs[name]
+      end
+    end
+  end
+end

data/lib/vagrant/config/error_recorder.rb

@@ -0,0 +1,19 @@
+module Vagrant
+  module Config
+    # A class which is passed into the various {Base#validate} methods and
+    # can be used as a helper to add error messages about a single config
+    # class.
+    class ErrorRecorder
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      # Adds an error to the list of errors.
+      def add(message)
+        @errors << message
+      end
+    end
+  end
+end

data/lib/vagrant/config/loader.rb

@@ -0,0 +1,127 @@
+require "pathname"
+
+require "log4r"
+
+module Vagrant
+  module Config
+    # This class is responsible for loading Vagrant configuration,
+    # usually in the form of Vagrantfiles.
+    #
+    # Loading works by specifying the sources for the configuration
+    # as well as the order the sources should be loaded. Configuration
+    # set later always overrides those set earlier; this is how
+    # configuration "scoping" is implemented.
+    class Loader
+      # This is an array of symbols specifying the order in which
+      # configuration is loaded. For examples, see the class documentation.
+      attr_accessor :load_order
+
+      def initialize
+        @logger  = Log4r::Logger.new("vagrant::config::loader")
+        @sources = {}
+        @proc_cache = {}
+        @config_cache = {}
+      end
+
+      # Set the configuration data for the given name.
+      #
+      # The `name` should be a symbol and must uniquely identify the data
+      # being given.
+      #
+      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
+      # `data` can also be an array of such values.
+      #
+      # At this point, no configuration is actually loaded. Note that calling
+      # `set` multiple times with the same name will override any previously
+      # set values. In this way, the last set data for a given name wins.
+      def set(name, sources)
+        @logger.debug("Set #{name.inspect} = #{sources.inspect}")
+
+        # Sources should be an array
+        sources = [sources] if !sources.kind_of?(Array)
+
+        # Gather the procs for every source, since that is what we care about.
+        procs = []
+        sources.each do |source|
+          if !@proc_cache.has_key?(source)
+            # Load the procs for this source and cache them. This caching
+            # avoids the issue where a file may have side effects when loading
+            # and loading it multiple times causes unexpected behavior.
+            @logger.debug("Populating proc cache for #{source.inspect}")
+            @proc_cache[source] = procs_for_source(source)
+          end
+
+          # Add on to the array of procs we're going to use
+          procs.concat(@proc_cache[source])
+        end
+
+        # Set this source by name.
+        @sources[name] = procs
+      end
+
+      # This loads the configured sources in the configured order and returns
+      # an actual configuration object that is ready to be used.
+      def load
+        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
+
+        unknown_sources = @sources.keys - @load_order
+        if !unknown_sources.empty?
+          # TODO: Raise exception here perhaps.
+          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
+        end
+
+        # Create the top-level configuration which will hold all the config.
+        result = Top.new
+
+        @load_order.each do |key|
+          next if !@sources.has_key?(key)
+
+          @sources[key].each do |proc|
+            if !@config_cache.has_key?(proc)
+              @logger.debug("Loading from: #{key} (evaluating)")
+              current = Top.new
+              proc.call(current)
+              @config_cache[proc] = current
+            else
+              @logger.debug("Loading from: #{key} (cache)")
+            end
+
+            # Merge in the results of this proc's configuration
+            result = result.merge(@config_cache[proc])
+          end
+        end
+
+        @logger.debug("Configuration loaded successfully")
+        result
+      end
+
+      protected
+
+      # This returns an array of `Proc` objects for the given source.
+      # The `Proc` objects returned will expect a single argument for
+      # the configuration object and are expected to mutate this
+      # configuration object.
+      def procs_for_source(source)
+        return [source] if source.is_a?(Proc)
+
+        # Assume all string sources are actually pathnames
+        source = Pathname.new(source) if source.is_a?(String)
+
+        if source.is_a?(Pathname)
+          @logger.debug("Load procs for pathname: #{source.inspect}")
+
+          begin
+            return Config.capture_configures do
+              Kernel.load source
+            end
+          rescue SyntaxError => e
+            # Report syntax errors in a nice way.
+            raise Errors::VagrantfileSyntaxError, :file => e.message
+          end
+        end
+
+        raise Exception, "Unknown configuration source: #{source.inspect}"
+      end
+    end
+  end
+end

data/lib/vagrant/config/nfs.rb

@@ -0,0 +1,8 @@
+module Vagrant
+  module Config
+    class NFSConfig < Base
+      attr_accessor :map_uid
+      attr_accessor :map_gid
+    end
+  end
+end

data/lib/vagrant/config/package.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Config
+    class PackageConfig < Base
+      attr_accessor :name
+    end
+  end
+end

data/lib/vagrant/config/ssh.rb

@@ -0,0 +1,27 @@
+module Vagrant
+  module Config
+    class SSHConfig < Base
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :host
+      attr_accessor :port
+      attr_accessor :guest_port
+      attr_accessor :max_tries
+      attr_accessor :timeout
+      attr_accessor :private_key_path
+      attr_accessor :forward_agent
+      attr_accessor :forward_x11
+      attr_accessor :shell
+
+      def validate(env, errors)
+        [:username, :host, :max_tries, :timeout].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+
+        if private_key_path && !File.file?(File.expand_path(private_key_path, env.root_path))
+          errors.add(I18n.t("vagrant.config.ssh.private_key_missing", :path => private_key_path))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/top.rb

@@ -0,0 +1,72 @@
+module Vagrant
+  module Config
+    # This class is the "top" configure class, which handles registering
+    # other configuration classes as well as validation of all configured
+    # classes. This is the object which is returned by {Environment#config}
+    # and has accessors to all other configuration classes.
+    #
+    # If you're looking to create your own configuration class, see {Base}.
+    class Top < Base
+      attr_reader :keys
+
+      def initialize(registry=nil)
+        @keys = {}
+        @registry = registry || Vagrant.config_keys
+      end
+
+      # We use method_missing as a way to get the configuration that is used
+      # for Vagrant and load the proper configuration classes for each.
+      def method_missing(name, *args)
+        return @keys[name] if @keys.has_key?(name)
+
+        config_klass = @registry.get(name.to_sym)
+        if config_klass
+          # Instantiate the class and return the instance
+          @keys[name] = config_klass.new
+          return @keys[name]
+        else
+          # Super it up to probably raise a NoMethodError
+          super
+        end
+      end
+
+      # Custom implementation to merge each key separately.
+      def merge(other)
+        result = self.class.new
+        @keys.each do |key, value|
+          result.keys[key] = value.merge(other.send(key))
+        end
+
+        other.keys.each do |key, value|
+          if !@keys.has_key?(key)
+            # This is a key that the other configuration class has
+            # that we don't, so just copy it in.
+            result.keys[key] = value.dup
+          end
+        end
+
+        result
+      end
+
+      # Validates the configuration classes of this instance and raises an
+      # exception if they are invalid. If you are implementing a custom configuration
+      # class, the method you want to implement is {Base#validate}. This is
+      # the method that checks all the validation, not one which defines
+      # validation rules.
+      def validate!(env)
+        # Validate each of the configured classes and store the results into
+        # a hash.
+        errors = @keys.inject({}) do |container, data|
+          key, instance = data
+          recorder = ErrorRecorder.new
+          instance.validate(env, recorder)
+          container[key.to_sym] = recorder if !recorder.errors.empty?
+          container
+        end
+
+        return if errors.empty?
+        raise Errors::ConfigValidationFailed, :messages => Util::TemplateRenderer.render("config/validation_failed", :errors => errors)
+      end
+    end
+  end
+end

data/lib/vagrant/config/vagrant.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  module Config
+    class VagrantConfig < Base
+      attr_accessor :dotfile_name
+      attr_accessor :host
+
+      def validate(env, errors)
+        [:dotfile_name, :host].each do |field|
+          errors.add(I18n.t("vagrant.config.common.error_empty", :field => field)) if !instance_variable_get("@#{field}".to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/config/vm.rb

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