vagrant-masonry 0.13.0

data/lib/config_builder/model/provider/vmware.rb

@@ -0,0 +1,40 @@
+# @see http://docs.vagrantup.com/v2/vmware/configuration.html
+class ConfigBuilder::Model::Provider::VMware < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] vmx
+  #   @return [Hash<String, String>] A hash of VMX options for the given VM
+  #   @example
+  #     model.vmx = {
+  #       'memsize'  => '1024',
+  #       'numvcpus' => '2',
+  #     }
+  def_model_attribute :vmx
+
+  # @!attribute [rw] gui
+  #   @return [Boolean] Whether the GUI should be launched when the VM is created
+  def_model_attribute :gui
+
+  def initialize
+    @defaults = {
+      :gui => false,
+      :vmx => {},
+    }
+
+    @providers ||= %w[vmware_fusion vmware_workstation]
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      @providers.each do |vmware_provider|
+        vm_config.provider vmware_provider do |config|
+          config.gui = attr(:gui)
+          attr(:vmx).each_pair do |key, value|
+            config.vmx[key] = value
+          end
+        end
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('vmware', self)
+end

data/lib/config_builder/model/provider/vmware_fusion.rb

@@ -0,0 +1,8 @@
+class ConfigBuilder::Model::Provider::VMwareFusion < ConfigBuilder::Model::Provider::VMware
+  def initialize
+    @providers = %w[vmware_fusion]
+    super
+  end
+
+  ConfigBuilder::Model::Provider.register('vmware_fusion', self)
+end

data/lib/config_builder/model/provider/vmware_workstation.rb

@@ -0,0 +1,8 @@
+class ConfigBuilder::Model::Provider::VMwareWorkstation < ConfigBuilder::Model::Provider::VMware
+  def initialize
+    @providers = %w[vmware_workstation]
+    super
+  end
+
+  ConfigBuilder::Model::Provider.register('vmware_workstation', self)
+end

data/lib/config_builder/model/provider/vsphere.rb

@@ -0,0 +1,30 @@
+# @see https://github.com/nsidc/vagrant-vsphere
+class ConfigBuilder::Model::Provider::Vsphere< ConfigBuilder::Model::Base
+
+  VSPHERE_ATTRIBUTES = [ :host, :insecure, :user, :password, :data_center_name, :compute_resource_name, :resource_pool_name, :clone_from_vm, :template_name, :name, :vm_base_path, :customization_spec_name, :data_store_name, :linked_clone, :proxy_host, :proxy_port, :vlan ]
+
+  # @!attribute [rw]
+  # The mandatory attributes will be verified by vagrant-vsphere
+  # @see https://github.com/nsidc/vagrant-vsphere#configuration
+  VSPHERE_ATTRIBUTES.each do |key|
+    def_model_attribute attr
+  end
+
+  def initialize
+    @defaults = {
+      :insecure => false,
+    }
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provider 'vsphere' do |config|
+        VSPHERE_ATTRIBUTES.each do |key|
+          config.send("#{key}=", attr(key)) if attr(key)
+        end
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('vsphere', self)
+end

data/lib/config_builder/model/provisioner/file.rb

@@ -0,0 +1,24 @@
+# @see http://docs.vagrantup.com/v2/provisioning/file.html
+class ConfigBuilder::Model::Provisioner::File < ConfigBuilder::Model::Base
+  # @!attribute [rw] source
+  #   @return [Source] Is the local path of the file to be uploaded.
+  def_model_attribute :source
+
+  # @!attribute [rw] destination
+  #   @return [Source] Is the remote path on the guest machine where the file
+  #     will be uploaded to. The file is uploaded as the SSH user over SCP, so
+  #     this location must be writable to that user. The SSH user can be
+  #     determined by running vagrant ssh-config, and defaults to "vagrant".
+  def_model_attribute :destination
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provision :file do |file_config|
+        with_attr(:source)        { |val| file_config.source = val }
+        with_attr(:destination)   { |val| file_config.destination = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provisioner.register('file', self)
+end

data/lib/config_builder/model/provisioner/puppet.rb

@@ -0,0 +1,37 @@
+# @see http://docs.vagrantup.com/v2/provisioning/puppet_apply.html
+class ConfigBuilder::Model::Provisioner::Puppet < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] manifests_path
+  #   @return [String] The path to the puppet manifests.
+  attr_accessor :manifests_path
+
+  # @!attribute [rw] manifest_file
+  #   @return [String] The name of the manifest to apply
+  attr_accessor :manifest_file
+
+  # @!attribute [rw] module_path
+  #   @return [String] A colon separated set of filesystem paths for Puppet
+  attr_accessor :module_path
+
+  # @!attribute [rw] facter
+  #   @return [Hash] A hash of values to use as facts
+  attr_accessor :facter
+
+  # @!attribute [rw] options
+  #   @return [String] An arbitrary set of arguments for the `puppet` command
+  attr_accessor :options
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provision :puppet do |puppet_config|
+        with_attr(:manifests_path) { |val| puppet_config.manifests_path = val }
+        with_attr(:manifest_file)  { |val| puppet_config.manifest_file  = val }
+        with_attr(:module_path)    { |val| puppet_config.module_path    = val }
+        with_attr(:facter)         { |val| puppet_config.facter         = val }
+        with_attr(:options)        { |val| puppet_config.options        = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provisioner.register('puppet', self)
+end

data/lib/config_builder/model/provisioner/puppet_server.rb

@@ -0,0 +1,27 @@
+# @see http://docs.vagrantup.com/v2/provisioning/puppet_agent.html
+class ConfigBuilder::Model::Provisioner::PuppetServer < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] puppet_server
+  #   @return [String]
+  attr_accessor :puppet_server
+
+  # @!attribute [rw] node_name
+  #   @return [String]
+  attr_accessor :node_name
+
+  # @!attribute [rw] options
+  #   @return [String]
+  attr_accessor :options
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provision :puppet_server do |puppet_config|
+        with_attr(:puppet_server) { |val| puppet_config.puppet_server = val }
+        with_attr(:node_name)     { |val| puppet_config.node_name     = val }
+        with_attr(:options)       { |val| puppet_config.options       = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provisioner.register('puppet_server', self)
+end

data/lib/config_builder/model/provisioner/shell.rb

@@ -0,0 +1,27 @@
+# @see http://docs.vagrantup.com/v2/provisioning/shell.html
+class ConfigBuilder::Model::Provisioner::Shell < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] inline
+  #   @return [String] The inline shell command to run
+  def_model_attribute :inline
+
+  # @!attribute [rw] path
+  #   @return [String] The path to the shell script to run
+  def_model_attribute :path
+
+  # @!attribute [rw] args
+  #   @return [String] A string acting as an argument vector to the command.
+  def_model_attribute :args
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provision :shell do |shell_config|
+        with_attr(:inline) { |val| shell_config.inline = val }
+        with_attr(:path)   { |val| shell_config.path   = val }
+        with_attr(:args)   { |val| shell_config.args   = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provisioner.register('shell', self)
+end

data/lib/config_builder/model/root.rb

@@ -0,0 +1,69 @@
+# Model the root level Vagrant config object
+#
+# @see http://docs.vagrantup.com/v2/vagrantfile/index.html
+class ConfigBuilder::Model::Root < ConfigBuilder::Model::Base
+
+  include ConfigBuilder::ModelDelegator
+
+  def_model_delegator :vagrant
+  def_model_delegator :vms
+
+  # @!attribute [rw] ssh
+  #   @return [Hash<Symbol, Object>] The ssh configuration for all VMs
+  #   @example
+  #     >> config.ssh
+  #     => {
+  #           :username => 'administrator',
+  #           :password => 'vagrant',
+  #        }
+  def_model_delegator :ssh
+
+  # @!attribute [rw] winrm
+  #   @return [Hash<Symbol, Object>] The winrm configuration for all VMs
+  #   @example
+  #     >> config.winrm
+  #     => {
+  #           :username => 'administrator',
+  #           :password => 'vagrant',
+  #        }
+  def_model_delegator :winrm
+
+  def initialize
+    @defaults = {:vms => [], :vagrant => {}}
+  end
+
+  def to_proc
+    Proc.new do |root_config|
+      eval_models(root_config)
+    end
+  end
+
+  private
+
+  def eval_vms(root_config)
+    attr(:vms).each do |hash|
+      v = ConfigBuilder::Model::VM.new_from_hash(hash)
+      v.call(root_config)
+    end
+  end
+
+  def eval_vagrant(root_config)
+    if attr(:vagrant).has_key? :host
+      root_config.vagrant.host = attr(:vagrant)[:host]
+    end
+  end
+
+  def eval_ssh(root_config)
+    with_attr(:ssh) do |ssh_config|
+      f = ConfigBuilder::Model::SSH.new_from_hash(ssh_config)
+      f.call(root_config)
+    end
+  end
+
+  def eval_winrm(root_config)
+    if attr(:winrm)
+      f = ConfigBuilder::Model::WinRM.new_from_hash(attr(:winrm))
+      f.call(root_config)
+    end
+  end
+end

data/lib/config_builder/model/ssh.rb

@@ -0,0 +1,110 @@
+# Vagrant SSH credential model
+#
+# @see http://docs.vagrantup.com/v2/vagrantfile/ssh_settings.html
+class ConfigBuilder::Model::SSH < ConfigBuilder::Model::Base
+  # @!attribute [rw] username
+  #   @return [String] This sets the username that Vagrant will SSH as by
+  #     default. Providers are free to override this if they detect a more
+  #     appropriate user. By default this is "vagrant," since that is what most
+  #     public boxes are made as.
+  def_model_attribute :username
+
+  # @!attribute [rw] password
+  #   @return [String] This sets a password that Vagrant will use to
+  #     authenticate the SSH user. Note that Vagrant recommends you use
+  #     key-based authentiation rather than a password (see #private_key_path)
+  #     below. If you use a password, Vagrant will automatically insert a
+  #     keypair if `insert_key` is true.
+  def_model_attribute :password
+
+  # @!attribute [rw] host
+  #   @return [String] The hostname or IP to SSH into. By default this is
+  #     empty, because the provider usually figures this out for you.
+  def_model_attribute :host
+
+  # @!attribute [rw] port
+  #   @return [Fixnum] The port to SSH into. By default this is port 22.
+  def_model_attribute :port
+
+  # @!attribute [rw] guest_port
+  #   @return [Fixnum] The port on the guest that SSH is running on. This is
+  #     used by some providers to detect forwarded ports for SSH. For example,
+  #     if this is set to 22 (the default), and Vagrant detects a forwarded
+  #     port to port 22 on the guest from port 4567 on the host, Vagrant will
+  #     attempt to use port 4567 to talk to the guest if there is no other
+  #     option.
+  def_model_attribute :guest_port
+
+  # @!attribute [rw] private_key_path
+  #   @return [String] The path to the private key to use to SSH into the guest
+  #     machine. By default this is the insecure private key that ships with
+  #     Vagrant, since that is what public boxes use. If you make your own
+  #     custom box with a custom SSH key, this should point to that private
+  #     key.
+  #
+  #     You can also specify multiple private keys by setting this to be an
+  #     array. This is useful, for example, if you use the default private key
+  #     to bootstrap the machine, but replace it with perhaps a more secure key
+  #     later.
+  def_model_attribute :private_key_path
+
+  # @!attribute [rw] forward_agent
+  #   @return [Boolean] If `true`, agent forwarding over SSH connections is
+  #     enabled. Defaults to `false`.
+  def_model_attribute :forward_agent
+
+  # @!attribute [rw] forward_x11
+  #   @return [Boolean] If `true`, X11 forwarding over SSH connections is
+  #     enabled. Defaults to `false`.
+  def_model_attribute :forward_x11
+
+  # @!attribute [rw] insert_key
+  #   @return [Boolean] If `true`, Vagrant will automatically insert an insecure
+  #     keypair to use for SSH. By default, this is `true`. This only has an
+  #     effect if you don't already use private keys for authentication.
+  def_model_attribute :insert_key
+
+  # @!attribute [rw] proxy_command
+  #   @return [String] A command-line command to execute that receives the data
+  #     to send to SSH on stdin. This can be used to proxy the SSH connection.
+  #     `%h` in the command is replaced with the host and `%p` is replaced with
+  #     the port.
+  def_model_attribute :proxy_command
+
+  # @!attribute [rw] pty
+  #   @return [Boolean] If `true`, pty will be used for provisioning. Defaults
+  #     to `false`.
+  #
+  #     This setting is an _advanced feature_ that should not be enabled unless
+  #     absolutely necessary. It breaks some other features of Vagrant, and is
+  #     really only exposed for cases where it is absolutely necessary. If you
+  #     can find a way to not use a pty, that is recommended instead.
+  def_model_attribute :pty
+
+  # @!attribute [rw] shell
+  #   @return [String] The shell to use when executing SSH commands from
+  #     Vagrant. By default this is `bash -l`. Note that this has no effect on
+  #     the shell you get when you run `vagrant ssh`. This configuration option
+  #     only affects the shell to use when executing commands internally in
+  #     Vagrant.
+  def_model_attribute :shell
+
+  def to_proc
+    Proc.new do |global_config|
+      ssh = global_config.ssh
+
+      with_attr(:username)         { |val| ssh.username = val }
+      with_attr(:password)         { |val| ssh.password = val }
+      with_attr(:host)             { |val| ssh.host = val }
+      with_attr(:port)             { |val| ssh.port = val }
+      with_attr(:guest_port)       { |val| ssh.guest_port = val }
+      with_attr(:private_key_path) { |val| ssh.private_key_path = val }
+      with_attr(:forward_agent)    { |val| ssh.forward_agent = val }
+      with_attr(:forward_x11)      { |val| ssh.forward_x11 = val }
+      with_attr(:insert_key)       { |val| ssh.insert_key = val }
+      with_attr(:proxy_command)    { |val| ssh.proxy_command = val }
+      with_attr(:pty)              { |val| ssh.pty = val }
+      with_attr(:shell)            { |val| ssh.shell = val }
+    end
+  end
+end

data/lib/config_builder/model/synced_folder.rb

@@ -0,0 +1,43 @@
+# Vagrant shared folder model.
+#
+# @see http://docs.vagrantup.com/v2/synced-folders/index.html
+class ConfigBuilder::Model::SyncedFolder < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] host_path
+  #   @return [String] The host file path to mount on the guest
+  def_model_attribute :host_path
+
+  # @!attribute [rw] guest_path
+  #   @return [String] The guest file path to be used as the mount point
+  def_model_attribute :guest_path
+
+  # @!attribute [rw] extra
+  #   A set of arbitrary options to pass to the virtualbox mount command.
+  #   @return [String]
+  def_model_attribute :extra
+
+  # @!attribute [rw] disabled
+  #   @return [Boolean] If the mount point should be disabled.
+  def_model_attribute :disabled
+
+  # @!attribute [rw] nfs
+  #   @return [Boolean] If the mount point should use NFS
+  def_model_attribute :nfs
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.synced_folder(attr(:host_path), attr(:guest_path), folder_opts)
+    end
+  end
+
+  private
+
+  def folder_opts
+    h = {}
+    with_attr(:extra)   { |val| h[:extra]    = val }
+    with_attr(:disabled) { |val| h[:disabled] = val }
+    with_attr(:nfs)     { |val| h[:nfs]      = val }
+
+    h
+  end
+end

data/lib/config_builder/model/vm.rb

@@ -0,0 +1,235 @@
+# @see http://docs.vagrantup.com/v2/vagrantfile/machine_settings.html
+class ConfigBuilder::Model::VM < ConfigBuilder::Model::Base
+
+  include ConfigBuilder::ModelDelegator
+
+  # @!attribute [rw] provider
+  #   @return [Hash<Symbol, Object>] The provider configuration for
+  #     this VM
+  #   @example
+  #     >> vm.provider
+  #     => {
+  #           :type => 'virtualbox',
+  #           :name => 'tiny-tina',
+  #           :gui  => false,
+  #        }
+  def_model_delegator :provider
+
+  # @!attribute [rw] providers
+  #   @return [Array<Hash{String, Symbol => Object}>] A collection of provider
+  #     parameters that should be applied to a VM.
+  #   @example
+  #     >> vm.providers
+  #     => [
+  #          {:type => 'virtualbox', :customize => ['modifyvm', :id, '--memory', 1024]},
+  #          {:type => 'vmware_fusion', :vmx => {:memsize => 1024}},
+  #        ]
+  def_model_delegator :providers
+
+  # @!attribute [rw] provisioners
+  #   @return [Array<Hash<Symbol, Object>>] A collection of provisioner
+  #     parameters in the order that they should be applied
+  #     of provisioner types, and a list of provisioner instances for each type
+  #   @example
+  #     >> vm.provisioners
+  #     => [
+  #           {:type => :shell, :path   => '/vagrant/bin/magic.sh'},
+  #           {:type => :shell, :inline => '/bin/echo hello world'},
+  #
+  #           {:type => :puppet, :manifest => 'foo.pp'},
+  #           {:type => :puppet, :manifest => 'bar.pp', :modulepath => '/vagrant/modules'},
+  #        ]
+  def_model_delegator :provisioners
+
+  # @!attribute [rw] forwarded_ports
+  #   @return [Array<Hash<Symbol, Object>>] A collection of port mappings
+  #   @example
+  #     >> vm.forwarded_ports
+  #     => [
+  #           {:guest => 80, :host  => 20080},
+  #           {:guest => 443, :host => 20443},
+  #        ]
+  def_model_delegator :forwarded_ports
+
+  # @!attribute [rw] private_networks
+  #   @return [Array<Hash<Symbol, Object>>] A collection of IP address network
+  #     settings.
+  #   @example
+  #     >> vm.private_networks
+  #     => [
+  #           {:ip => '10.20.4.1'},
+  #           {:ip => '192.168.100.5', :netmask => '255.255.255.128'},
+  #        ]
+  def_model_delegator :private_networks
+
+  # @!attribute [rw] synced_folders
+  #   @return [Array<Hash<Symbol, Object>>]
+  #   @example
+  #     >> vm.synced_folders
+  #     => [
+  #           {:host_path => 'manifests/', :guest_path => '/root/manifests', :disabled => false},
+  #           {:host_path => 'modules/', :guest_path => '/root/modules'},
+  #        ]
+  #
+  def_model_delegator :synced_folders
+
+  # @!attribute [rw] guest
+  #   @return [String] The guest type to use for this VM
+  def_model_attribute :guest
+
+  # @!attribute [rw] box
+  #   @return [String] This configures what box the machine will be brought up
+  #     against. The value here should be the name of an installed box or a
+  #     shorthand name of a box in Vagrant Cloud.
+  def_model_attribute :box
+
+  # @!attribute [rw] box_url
+  #   @return [String, Array<String>] The URL that the configured box can be
+  #     found at. If `box` is a shorthand to a box in Vagrant Cloud then this
+  #     value doesn't need to be specified. Otherwise, it should point to the
+  #     proper place where the box can be found if it isn't installed.
+  #
+  #     This can also be an array of multiple URLs. The URLs will be tried in
+  #     order. Note that any client certificates, insecure download settings,
+  #     and so on will apply to all URLs in this list.
+  #
+  #     The URLs can also be local files by using the file:// scheme. For
+  #     example: "file:///tmp/test.box".
+  def_model_attribute :box_url
+
+  # @!attribute [rw] box_download_checksum
+  #   @return [String] The checksum of the box specified by `box_url`.
+  #     If not specified, no checksum comparison will be done. If specified,
+  #     Vagrant will compare the checksum of the downloaded box to this value
+  #     and error if they do not match. Checksum checking is only done when
+  #     Vagrant must download the box.
+  #
+  #     If this is specified, then `box_download_checksum_type` must also be
+  #     specified.
+  def_model_attribute :box_download_checksum
+
+  # @!attribute [rw] box_download_checksum_type
+  #   @return [String] The type of checksum specified by
+  #     `box_download_checksum` (if any). Supported values are currently `md5`,
+  #     `sha1`, and `sha256`.
+  def_model_attribute :box_download_checksum_type
+
+  # @!attribute [rw] box_download_client_cert
+  #   @return [String] Path to a client certificate to use when downloading the
+  #     box, if it is necessary. By default, no client certificate is used to
+  #     download the box.
+  def_model_attribute :box_download_client_cert
+
+  # @!attribute [rw] box_download_insecure
+  #   @return [Boolean] If `true`, then SSL certificates from the server will
+  #     not be verified. By default, if the URL is an HTTPS URL, then SSL certs
+  #     will be verified.
+  def_model_attribute :box_download_insecure
+
+  # @!attribute [rw] box_check_update
+  #   @return [Boolean] If true, Vagrant will check for updates to the
+  #     configured box on every `vagrant up`. If an update is found, Vagrant
+  #     will tell the user. By default this is `true`. Updates will only be
+  #     checked for boxes that properly support updates (boxes from Vagrant
+  #     Cloud or some other versioned box).
+  def_model_attribute :box_check_update
+
+  # @!attribute [rw] box_version
+  #   @return [String] The version of the box to use. This defaults to ">= 0"
+  #     (the latest version available). This can contain an arbitrary list of
+  #     constraints, separated by commas, such as: >= 1.0, < 1.5. When
+  #     constraints are given, Vagrant will use the latest available box
+  #     satisfying these constraints.
+  def_model_attribute :box_version
+
+  # @!attribute [rw] name
+  #   @return [String] The name of the instantiated box in this environment
+  def_model_attribute :name
+
+  # @!attribute [rw] hostname
+  #   @return [String] The hostname the machine should have.
+  def_model_attribute :hostname
+
+  # @!attribute [rw] communicator
+  #   @return [String] The name of the communicator to use when sending
+  #   commands to this box. Set to 'winrm' for Windows VMs.
+  def_model_attribute :communicator
+
+  def initialize
+    @defaults = {
+      :providers        => [],
+      :provisioners     => [],
+      :forwarded_ports  => [],
+      :private_networks => [],
+      :synced_folders   => [],
+    }
+  end
+
+  def to_proc
+    Proc.new do |global_config|
+      global_config.vm.define(attr(:name)) do |config|
+        vm_config = config.vm
+
+        with_attr(:box)                        { |val| vm_config.box = val }
+        with_attr(:box_url)                    { |val| vm_config.box_url = val }
+        with_attr(:box_download_checksum)      { |val| vm_config.box_download_checksum = val }
+        with_attr(:box_download_checksum_type) { |val| vm_config.box_download_checksum_type = val }
+        with_attr(:box_download_client_cert)   { |val| vm_config.box_download_client_cert = val }
+        with_attr(:box_download_insecure)      { |val| vm_config.box_download_insecure = val }
+        with_attr(:box_check_update)           { |val| vm_config.box_check_update = val }
+        with_attr(:box_version)                { |val| vm_config.box_version = val }
+
+        with_attr(:hostname) { |val| vm_config.hostname = attr(:hostname) }
+        with_attr(:guest)    { |val| vm_config.guest    = attr(:guest)    }
+
+        with_attr(:communicator) { |val| vm_config.communicator = attr(:communicator) }
+
+        eval_models(vm_config)
+      end
+    end
+  end
+
+  private
+
+  def eval_provisioners(vm_config)
+    attr(:provisioners).each do |hash|
+      p = ConfigBuilder::Model::Provisioner.new_from_hash(hash)
+      p.call(vm_config)
+    end
+  end
+
+  def eval_providers(vm_config)
+    attr(:providers).each do |hash|
+      p = ConfigBuilder::Model::Provider.new_from_hash(hash)
+      p.call(vm_config)
+    end
+  end
+
+  def eval_provider(vm_config)
+    if attr(:provider)
+      p = ConfigBuilder::Model::Provider.new_from_hash(attr(:provider))
+      p.call(vm_config)
+    end
+  end
+
+  def eval_private_networks(vm_config)
+    attr(:private_networks).each do |hash|
+      n = ConfigBuilder::Model::Network::PrivateNetwork.new_from_hash(hash)
+      n.call(vm_config)
+    end
+  end
+
+  def eval_forwarded_ports(vm_config)
+    attr(:forwarded_ports).each do |hash|
+      f = ConfigBuilder::Model::Network::ForwardedPort.new_from_hash(hash)
+      f.call(vm_config)
+    end
+  end
+
+  def eval_synced_folders(vm_config)
+    attr(:synced_folders).each do |hash|
+      f = ConfigBuilder::Model::SyncedFolder.new_from_hash(hash)
+      f.call(vm_config)
+    end
+  end
+end