boxcar 0.10005.1

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

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