vagrant-masonry 0.13.0

data/lib/config_builder/loader/yaml_erb.rb

@@ -0,0 +1,24 @@
+require 'erb'
+
+class ConfigBuilder::Loader::YAML_ERB < ConfigBuilder::Loader::YAML
+
+  # Load configuration from a YAML file with ERB interpolation first
+  #
+  # @param file_path [String]
+  #
+  # @example the following config file will be processed by ERB first so it can
+  # determine whether to use the environment variable 'VAGRANT_MANIFEST' or the
+  # default value 'init.pp' for the puppet manifest file.
+  #
+  # ---
+  #   provisioner:
+  #     - type: puppet
+  #       manifest_file: <%= ENV['VAGRANT_MANIFEST'] || 'init.pp' >
+  #
+  # @return [Hash]
+  def yamlfile(file_path)
+    ::YAML.load(::ERB.new(File.read(file_path)).result)
+  end
+
+  ConfigBuilder::Loader.register(:yaml_erb, self)
+end

data/lib/config_builder/model.rb

@@ -0,0 +1,67 @@
+require 'vagrant/errors'
+require 'config_builder/class_registry'
+require 'config_builder/model_delegator'
+
+module ConfigBuilder
+
+  module Model
+
+    require 'config_builder/model/base'
+
+    require 'config_builder/model/root'
+
+    require 'config_builder/model/ssh'
+    require 'config_builder/model/winrm'
+    #require 'config_builder/model/host'
+
+    require 'config_builder/model/vm'
+    require 'config_builder/model/synced_folder'
+
+    def self.generate(hash)
+      ConfigBuilder::Model::Root.new_from_hash(hash)
+    end
+
+    module Network
+      require 'config_builder/model/network/forwarded_port'
+      require 'config_builder/model/network/private_network'
+    end
+
+    module Provider
+
+      @registry = ConfigBuilder::ClassRegistry.new(:provider)
+
+      def self.new_from_hash(hash)
+        @registry.generate(hash)
+      end
+
+      def self.register(name, klass)
+        @registry.register(name, klass)
+      end
+
+      require 'config_builder/model/provider/virtualbox'
+      require 'config_builder/model/provider/vmware'
+      require 'config_builder/model/provider/vmware_fusion'
+      require 'config_builder/model/provider/vmware_workstation'
+      require 'config_builder/model/provider/libvirt'
+      require 'config_builder/model/provider/vsphere'
+      require 'config_builder/model/provider/azure'
+    end
+
+    module Provisioner
+
+      @registry = ConfigBuilder::ClassRegistry.new(:provisioner)
+
+      def self.new_from_hash(hash)
+        @registry.generate(hash)
+      end
+
+      def self.register(name, klass)
+        @registry.register(name, klass)
+      end
+
+      require 'config_builder/model/provisioner/shell'
+      require 'config_builder/model/provisioner/puppet'
+      require 'config_builder/model/provisioner/puppet_server'
+    end
+  end
+end

data/lib/config_builder/model/base.rb

@@ -0,0 +1,101 @@
+# A ConfigBuilder model implements a logic-less interface to a component of
+# Vagrant.
+#
+# A model should implement the following methods:
+#
+# ## `self.new_from_hash`
+#
+# This method takes an arbitrarily nested data structure of basic data types
+# (Arrays, Hashes, Numerics, Strings, etc) and instantiates a new object
+# with attributes set based on that data structure.
+#
+# ## `#to_proc`
+#
+# This method takes the object attributes and generates a lambda that will
+# create a Vagrant config with the state specified by the attributes. The
+# lambda should have an arity of one and should be passed a `config` object.
+# The generated block will generate the Vagrant config that implements the
+# behavior specified by the object attributes.
+#
+# If the Model delegates certain configuration to other models, the generated
+# lambda should be able to evaluate lambdas from the delegated models.
+#
+# Implementing classes do not need to inherit from ConfigBuilder::Model::Base,
+# but it makes life easier.
+class ConfigBuilder::Model::Base
+
+  # Deserialize a hash into a configbuilder model
+  #
+  # @param attributes [Hash] The model attributes as represented in a hash.
+  # @return [Object < ConfigBuilder::Model]
+  def self.new_from_hash(attributes)
+    obj = new()
+    obj.attrs = attributes
+    obj
+  end
+
+  # @api private
+  def attrs=(config)
+    hash = config.inject({}) { |hash, (key, value)| hash[key.to_sym] = value; hash }
+
+    if @defaults
+      @attrs = @defaults.merge(hash)
+    else
+      @attrs = hash
+    end
+  end
+
+  # Generate a block based on configuration specified by the attributes
+  #
+  # @abstract
+  # @return [Proc]
+  def to_proc
+    raise NotImplementedError
+  end
+
+  # Generate a block based on the attribute configuration and call it with
+  # the given config.
+  #
+  # @param config [Vagrant.plugin('2', :config)]
+  # @return [void]
+  def call(config)
+    to_proc.call(config)
+  end
+
+  # @param identifier [Symbol]
+  #
+  # @return [Object] The value of the model attribute specified by `identifier`
+  #
+  # @todo validate identifier
+  def attr(identifier)
+    @attrs[identifier]
+  end
+  private :attr
+
+  # Conditionally evaluate a block with a model attribute if it's defined
+  #
+  # @since 0.6.0
+  #
+  # @param identifier [Symbol] The attribute identifier
+  #
+  # @return [void]
+  def with_attr(identifier)
+    val = @attrs[identifier]
+    unless val.nil?
+      yield val
+    end
+  end
+  private :with_attr
+
+  class << self
+
+    # @param identifier [Symbol]
+    def def_model_attribute(identifier)
+      model_attributes << identifier
+    end
+
+    def model_attributes
+      (@identifiers ||= [])
+    end
+  end
+end

data/lib/config_builder/model/network/forwarded_port.rb

@@ -0,0 +1,37 @@
+# Vagrant forwarded port model
+#
+# @see http://docs.vagrantup.com/v2/networking/forwarded_ports.html
+class ConfigBuilder::Model::Network::ForwardedPort < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] guest
+  #   @return [Fixnum] The guest port
+  def_model_attribute :guest
+
+  # @!attribute [rw] host
+  #   @return [Fixnum] The host port
+  def_model_attribute :host
+
+  # @!attribute [rw] auto_correct
+  #   @return [Boolean] Whether to automatically correct port collisions
+  def_model_attribute :auto_correct
+
+  # @!attribute [rw] id
+  #   @return [String, nil] An optional name used to identify this port forward
+  def_model_attribute :id
+
+  def initialize
+    @defaults = {:auto_correct => false, :id => nil}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.network(
+        :forwarded_port,
+        :guest        => attr(:guest),
+        :host         => attr(:host),
+        :auto_correct => attr(:auto_correct),
+        :id           => attr(:id),
+      )
+    end
+  end
+end

data/lib/config_builder/model/network/private_network.rb

@@ -0,0 +1,15 @@
+# Vagrant private network
+#
+# @see http://docs.vagrantup.com/v2/networking/private_network.html
+class ConfigBuilder::Model::Network::PrivateNetwork < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] :ip
+  #   @return [String] The IP address to use for the private network interface
+  def_model_attribute :ip
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.network(:private_network, @attrs)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# @see https://github.com/MSOpenTech/vagrant-azure
+class ConfigBuilder::Model::Provider::Azure < ConfigBuilder::Model::Base
+
+  def_model_attribute :mgmt_certificate
+  def_model_attribute :mgmt_endpoint
+  def_model_attribute :subscription_id
+  def_model_attribute :storage_acct_name
+  def_model_attribute :storage_access_key
+
+  def_model_attribute :vm_name
+  def_model_attribute :vm_user
+  def_model_attribute :vm_password
+  def_model_attribute :vm_image
+  def_model_attribute :vm_location
+  def_model_attribute :vm_affinity_group
+
+  def_model_attribute :cloud_service_name
+  def_model_attribute :deployment_name
+  def_model_attribute :tcp_endpoints
+  def_model_attribute :ssh_private_key_file
+  def_model_attribute :ssh_certificate_file
+  def_model_attribute :ssh_port
+  def_model_attribute :vm_size
+  def_model_attribute :winrm_transport
+  def_model_attribute :winrm_http_port
+  def_model_attribute :winrm_https_port
+  def_model_attribute :availability_set_name
+
+  def_model_attribute :state_read_timeout
+
+  def initialize
+    @defaults = {}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provider 'azure' do |config|
+        with_attr(:mgmt_certificate)      { |val| config.mgmt_certificate = val }
+        with_attr(:mgmt_endpoint)         { |val| config.mgmt_endpoint = val }
+        with_attr(:subscription_id)       { |val| config.subscription_id = val }
+        with_attr(:storage_acct_name)     { |val| config.storage_acct_name = val }
+        with_attr(:storage_access_key)    { |val| config.storage_access_key = val }
+        with_attr(:vm_name)               { |val| config.vm_name = val }
+        with_attr(:vm_user)               { |val| config.vm_user = val }
+        with_attr(:vm_password)           { |val| config.vm_password = val }
+        with_attr(:vm_image)              { |val| config.vm_image = val }
+        with_attr(:vm_location)           { |val| config.vm_location = val }
+        with_attr(:vm_affinity_group)     { |val| config.vm_affinity_group = val }
+        with_attr(:cloud_service_name)    { |val| config.cloud_service_name = val }
+        with_attr(:deployment_name)       { |val| config.deployment_name = val }
+        with_attr(:tcp_endpoints)         { |val| config.tcp_endpoints = val }
+        with_attr(:ssh_private_key_file)  { |val| config.ssh_private_key_file = val }
+        with_attr(:ssh_certificate_file)  { |val| config.ssh_certificate_file = val }
+        with_attr(:ssh_port)              { |val| config.ssh_port = val }
+        with_attr(:vm_size)               { |val| config.vm_size = val }
+        with_attr(:winrm_transport)       { |val| config.winrm_transport = val }
+        with_attr(:winrm_http_port)       { |val| config.winrm_http_port = val }
+        with_attr(:winrm_https_port)      { |val| config.winrm_https_port = val }
+        with_attr(:availability_set_name) { |val| config.availability_set_name = val }
+        with_attr(:state_read_timeout)    { |val| config.state_read_timeout = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('azure', self)
+end

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

@@ -0,0 +1,108 @@
+# @see http://github.com/pradels/vagrant-libvirt
+class ConfigBuilder::Model::Provider::Libvirt < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] uri
+  #   @return [String] Manually specify URI
+  def_model_attribute :uri
+
+  # @!attribute [rw] driver
+  #   @return [String] A hypervisor name to access via Libvirt.
+  def_model_attribute :driver
+
+  # @!attribute [rw] host
+  #   @return [String] The name of the server, where libvirtd is running.
+  def_model_attribute :host
+
+  # @!attribute [rw] connect_via_ssh
+  #   @return [String] If use ssh tunnel to connect to Libvirt.
+  def_model_attribute :connect_via_ssh 
+
+  # @!attribute [rw] socket
+  #   @return [String] Path towards the libvirt socket
+  def_model_attribute :socket
+
+  # @!attribute [rw] username
+  #   @return [String] The username to access Libvirt.
+  def_model_attribute :username
+
+  # @!attribute [rw] password
+  #   @return [String] Password for Libvirt connection.
+  def_model_attribute :password
+
+  # @!attribute [rw] id_ssh_key_file
+  #   @return [String] ID SSH key file
+  def_model_attribute :id_ssh_key_file
+
+  # @!attribute [rw] storage_pool_name
+  #   @return [String] Libvirt storage pool name, where box image and instance
+  #   snapshots will be stored.
+  def_model_attribute :storage_pool_name
+
+  # @!attribute [rw] random_hostname
+  #   @return [String] Turn on to prevent hostname conflicts
+  def_model_attribute :random_hostname
+
+  # @!attribute [rw] management_network_name
+  #   @return [String] Libvirt default network name
+  def_model_attribute :management_network_name
+
+  # @!attribute [rw] management_network_address
+  #   @return [String] Libvirt default network address
+  def_model_attribute :management_network_address
+
+  # @!attribute [rw] default_prefix
+  #   @return [String] Default host prefix (alternative to use project folder
+  #   name)
+  def_model_attribute :default_prefix
+
+  # Domain specific settings used while creating new domain.
+  def_model_attribute :memory
+  def_model_attribute :cpus
+  def_model_attribute :cpu_mode
+  def_model_attribute :disk_bus
+  def_model_attribute :nested
+  def_model_attribute :volume_cache
+  def_model_attribute :kernel
+  def_model_attribute :cmd_line
+  def_model_attribute :initrd
+
+  def initialize
+    @defaults = {}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provider 'libvirt' do |vb_config|
+
+        with_attr(:uri)               { |val| vb_config.host = val }
+        with_attr(:driver)            { |val| vb_config.host = val }
+        with_attr(:host)              { |val| vb_config.host = val }
+        with_attr(:connect_via_ssh)   { |val| vb_config.connect_via_ssh = val }
+        with_attr(:socket)            { |val| vb_config.socket = val }
+        with_attr(:username)          { |val| vb_config.username = val }
+        with_attr(:password)          { |val| vb_config.username = val }
+        with_attr(:id_ssh_key_file)   { |val| vb_config.id_ssh_key_file = val }
+        with_attr(:storage_pool_name) { |val| vb_config.storage_pool_name = val }
+        with_attr(:random_hostname)   { |val| vb_config.random_hostname = val }
+        with_attr(:management_network_name) { |val|
+          vb_config.username = val
+        }
+        with_attr(:management_network_address) { |val|
+          vb_config.username = val
+        }
+        with_attr(:default_prefix)    { |val| vb_config.username = val }
+        with_attr(:memory)            { |val| vb_config.memory = val }
+        with_attr(:cpus)              { |val| vb_config.cpus = val }
+        with_attr(:cpu_mode)          { |val| vb_config.cpu_mode = val }
+        with_attr(:disk_bus)          { |val| vb_config.disk_bus = val }
+        with_attr(:nested)            { |val| vb_config.nested = val }
+        with_attr(:volume_cache)      { |val| vb_config.volume_cache = val }
+        with_attr(:kernel)            { |val| vb_config.kernel = val }
+        with_attr(:cmd_line)          { |val| vb_config.cmd_line = val }
+        with_attr(:initrd)            { |val| vb_config.initrd = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('libvirt', self)
+end

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

@@ -0,0 +1,35 @@
+# @see http://docs.vagrantup.com/v2/virtualbox/configuration.html
+class ConfigBuilder::Model::Provider::Virtualbox < ConfigBuilder::Model::Base
+
+  # @!attribute [rw] name
+  #   @return [String] The name of the created VM in the Virtualbox GUI
+  def_model_attribute :name
+
+  # @!attribute [rw] customize
+  #   @return [Array<String>] A list of customize arguments to use upon VM instantiation.
+  def_model_attribute :customize
+
+  # @!attribute [rw] gui
+  #   @return [Boolean] Whether the GUI should be launched when the VM is created
+  def_model_attribute :gui
+
+  def initialize
+    @defaults = {:customize => []}
+  end
+
+  def to_proc
+    Proc.new do |vm_config|
+      vm_config.provider 'virtualbox' do |vb_config|
+        with_attr(:name) { |val| vb_config.name = val }
+
+        attr(:customize).each do |cmd|
+          vb_config.customize cmd
+        end
+
+        with_attr(:gui) { |val| vb_config.gui = val }
+      end
+    end
+  end
+
+  ConfigBuilder::Model::Provider.register('virtualbox', self)
+end