Class: Vagrant::Config::V2::Root

Inherits:
Object
  • Object
show all
Defined in:
lib/vagrant/config/v2/root.rb

Overview

This is the root configuration class. An instance of this is what is passed into version 2 Vagrant configuration blocks.

Instance Method Summary collapse

Constructor Details

#initialize(config_map, keys = nil) ⇒ Root

Initializes a root object that maps the given keys to specific configuration classes.

Parameters:

  • config_map (Hash) —

    Map of key to config class.



18
19
20
21
22
23
 
# File 'lib/vagrant/config/v2/root.rb', line 18

def initialize(config_map, keys=nil)
  @keys              = keys || {}
  @config_map        = config_map
  @missing_key_calls = Set.new
  @logger            = Log4r::Logger.new("vagrant::config")
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object

We use method_missing as a way to get the configuration that is used for Vagrant and load the proper configuration classes for each.



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/vagrant/config/v2/root.rb', line 28

def method_missing(name, *args)
  return @keys[name] if @keys.key?(name)

  config_klass = @config_map[name.to_sym]
  if config_klass
    # Instantiate the class and return the instance
    @keys[name] = config_klass.new
  else
    @logger.debug("missing key request name=#{name} loc=#{caller.first}")
    # Record access to a missing key as an error
    @missing_key_calls.add(name.to_s)
    @keys[name] = DummyConfig.new
  end

  @keys[name]
end

Instance Method Details

#__internal_state ⇒ Object

Returns the internal state of the root object. This is used by outside classes when merging, and shouldn't be called directly. Note the strange method name is to attempt to avoid any name clashes with potential configuration keys.



104
105
106
107
108
109
110
 
# File 'lib/vagrant/config/v2/root.rb', line 104

def __internal_state
  {
    "config_map"        => @config_map,
    "keys"              => @keys,
    "missing_key_calls" => @missing_key_calls
  }
end

#__set_internal_state(state) ⇒ Object

This sets the internal state. This is used by the core to do some merging logic and shouldn't be used by the general public.



114
115
116
117
118
 
# File 'lib/vagrant/config/v2/root.rb', line 114

def __set_internal_state(state)
  @config_map        = state["config_map"] if state.key?("config_map")
  @keys              = state["keys"] if state.key?("keys")
  @missing_key_calls = state["missing_key_calls"] if state.key?("missing_key_calls")
end

#finalize! ⇒ Object

Called to finalize this object just prior to it being used by the Vagrant system. The "!" signifies that this is expected to mutate itself.



48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/vagrant/config/v2/root.rb', line 48

def finalize!
  @config_map.each do |key, klass|
    if !@keys.key?(key)
      @keys[key] = klass.new
    end
  end

  @keys.each do |_key, instance|
    instance.finalize!
    instance._finalize!
  end
end

#validate(machine, ignore_provider = nil) ⇒ Hash

This validates the configuration and returns a hash of error messages by section. If there are no errors, an empty hash is returned.

Parameters:

Returns:

  • (Hash) 


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/vagrant/config/v2/root.rb', line 67

def validate(machine, ignore_provider=nil)
  # Go through each of the configuration keys and validate
  errors = {}
  @keys.each do |_key, instance|
    if instance.respond_to?(:validate)
      # Validate this single item, and if we have errors then
      # we merge them into our total errors list.
      if _key == :vm
        result = instance.validate(machine, ignore_provider)
      else
        result = instance.validate(machine)
      end
      if result && !result.empty?
        errors = Util.merge_errors(errors, result)
      end
    end
  end

  # Go through and delete empty keys
  errors.keys.each do |key|
    errors.delete(key) if errors[key].empty?
  end

  # If we have missing keys, record those as errors
  if !@missing_key_calls.empty?
    errors["Vagrant"] = @missing_key_calls.to_a.sort.map do |key|
      I18n.t("vagrant.config.root.bad_key", key: key)
    end
  end

  errors
end