rvagrant 0.8.7.dev

data/lib/vagrant/config/package.rb

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

data/lib/vagrant/config/ssh.rb

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

data/lib/vagrant/config/top.rb

@@ -0,0 +1,61 @@
+module Vagrant
+  class 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
+      @@configures = {} if !defined?(@@configures)
+
+      # The environment that this configuration is for.
+      attr_reader :env
+
+      class << self
+        # The list of registered configuration classes as well as the key
+        # they're registered under.
+        def configures_list
+          @@configures ||= {}
+        end
+
+        # Registers a configuration class with the given key. This method shouldn't
+        # be called. Instead, inherit from {Base} and call {Base.configures}.
+        def configures(key, klass)
+          configures_list[key] = klass
+          attr_reader key.to_sym
+        end
+      end
+
+      def initialize(env=nil)
+        self.class.configures_list.each do |key, klass|
+          config = klass.new
+          config.top = self
+          instance_variable_set("@#{key}".to_sym, config)
+        end
+
+        @env = env
+      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!
+        # Validate each of the configured classes and store the results into
+        # a hash.
+        errors = self.class.configures_list.inject({}) do |container, data|
+          key, _ = data
+          recorder = ErrorRecorder.new
+          send(key.to_sym).validate(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,17 @@
+module Vagrant
+  class Config
+    class VagrantConfig < Base
+      configures :vagrant
+
+      attr_accessor :dotfile_name
+      attr_accessor :host
+      attr_accessor :ssh_session_cache
+
+      def validate(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,148 @@
+require 'vagrant/config/vm/sub_vm'
+require 'vagrant/config/vm/provisioner'
+
+module Vagrant
+  class Config
+    class VMConfig < Base
+      configures :vm
+
+      include Util::StackedProcRunner
+
+      attr_accessor :auto_port_range
+      attr_accessor :box
+      attr_accessor :box_url
+      attr_accessor :box_ovf
+      attr_accessor :base_mac
+      attr_accessor :boot_mode
+      attr_accessor :host_name
+      attr_reader :forwarded_ports
+      attr_reader :shared_folders
+      attr_reader :network_options
+      attr_reader :provisioners
+      attr_accessor :system
+
+      def initialize
+        @forwarded_ports = {}
+        @shared_folders = {}
+        @network_options = []
+        @provisioners = []
+      end
+
+      def forward_port(name, guestport, hostport, options=nil)
+        options = {
+          :guestport  => guestport,
+          :hostport   => hostport,
+          :protocol   => :tcp,
+          :adapter    => 0,
+          :auto       => false
+        }.merge(options || {})
+
+        forwarded_ports[name] = options
+      end
+
+      def share_folder(name, guestpath, hostpath, opts=nil)
+        @shared_folders[name] = {
+          :guestpath => guestpath,
+          :hostpath => hostpath,
+          :owner => nil,
+          :group => nil,
+          :nfs   => false
+        }.merge(opts || {})
+      end
+
+      def network(ip, options=nil)
+        options = {
+          :ip => ip,
+          :netmask => "255.255.255.0",
+          :adapter => 1,
+          :mac => nil,
+          :name => nil
+        }.merge(options || {})
+
+        @network_options[options[:adapter]] = options
+      end
+
+      def provision(name, options=nil, &block)
+        @provisioners << Provisioner.new(top, name, options, &block)
+      end
+
+      def customize(&block)
+        push_proc(&block)
+      end
+
+      def has_multi_vms?
+        !defined_vms.empty?
+      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)
+      end
+
+      def validate(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.box
+        errors.add(I18n.t("vagrant.config.vm.boot_mode_invalid")) if ![:vrdp, :gui].include?(boot_mode.to_sym)
+        errors.add(I18n.t("vagrant.config.vm.base_mac_invalid")) if env.box && !base_mac
+
+        shared_folders.each do |name, options|
+          if !File.directory?(File.expand_path(options[:hostpath].to_s, env.root_path))
+            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
+        network_options.each do |options|
+          next if !options
+
+          ip = options[:ip].split(".")
+
+          if ip.length != 4
+            errors.add(I18n.t("vagrant.config.vm.network_ip_invalid",
+                              :ip => options[:ip]))
+          elsif ip.last == "1"
+            errors.add(I18n.t("vagrant.config.vm.network_ip_ends_one",
+                              :ip => options[:ip]))
+          end
+        end
+
+        # Each provisioner can validate itself
+        provisioners.each do |prov|
+          # TODO: Remove at some point
+          if prov.shortcut == :chef_server
+            errors.add(I18n.t("vagrant.config.vm.provisioner_chef_server_changed"))
+          else
+            prov.validate(errors)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Vagrant
+  class Config
+    class VMConfig < Base
+      # Represents a single configured provisioner for a VM.
+      class Provisioner
+        attr_reader :top
+        attr_reader :shortcut
+        attr_reader :provisioner
+        attr_reader :config
+
+        def initialize(top, shortcut, options=nil, &block)
+          @top = top
+          @shortcut = shortcut
+          @provisioner = shortcut
+          @provisioner = Provisioners::Base.registered[shortcut] if shortcut.is_a?(Symbol)
+          @config = nil
+
+          configure(options, &block)
+        end
+
+        # Configures the provisioner if it can (if it is valid).
+        def configure(options=nil, &block)
+          # We don't want ancestors to be searched. This is the default in 1.8,
+          # but not in 1.9, hence this hackery.
+          const_args = ["Config"]
+          const_args << false if RUBY_VERSION >= "1.9"
+
+          # We assume that every provisioner has a `Config` class beneath
+          # it for configuring.
+          return if !@provisioner || !@provisioner.const_defined?(*const_args)
+
+          # Instantiate the config class and configure it
+          @config = @provisioner.const_get(*const_args).new
+          @config.top = top
+          @config.set_options(options) if options
+          block.call(@config) if block
+        end
+
+        def validate(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(errors) if config
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Vagrant
+  class 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,70 @@
+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)
+      @file_path = file_path
+      return if !file_path
+
+      raise Errors::DotfileIsDirectory if File.directory?(file_path)
+
+      if File.exist?(file_path)
+        File.open(file_path, "r") do |f|
+          merge!(JSON.parse(f.read))
+        end
+      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
+      return if !file_path
+
+      clean_nil_and_empties
+
+      if empty?
+        # Delete the file since an empty data store is not useful
+        File.delete(file_path) if File.file?(file_path)
+      else
+        File.open(file_path, "w") { |f| f.write(to_json) }
+      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,23 @@
+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
+
+      # The environment which this downloader is operating.
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      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