vagrant-masonry 0.13.0

data/examples/Vagrantfile

@@ -0,0 +1 @@
+Vagrant.configure('2', &ConfigBuilder.load(:yaml, :yamldir, '/path/to/config'))

data/examples/roles.yaml

@@ -0,0 +1,29 @@
+---
+roles:
+  puppetmaster:
+    provider:
+      type: virtualbox
+      customize: [[modifyvm, !ruby/sym id, '--memory', 1024]]
+    provisioners:
+      -
+        type: shell
+        inline: 'echo "nameserver 8.8.8.8" > /etc/resolv.conf'
+      -
+        type: hosts
+      -
+        type: pe_bootstrap
+        role: !ruby/sym master
+        relocate_manifests: false
+        version: '2.6.0'
+  puppetagent:
+    provisioners:
+      -
+        type: shell
+        inline: 'echo "nameserver 8.8.8.8" > /etc/resolv.conf'
+      -
+        type: hosts
+      -
+        type: pe_bootstrap
+        role: !ruby/sym agent
+        version: '2.6.0'
+

data/examples/vms.yaml

@@ -0,0 +1,12 @@
+---
+vms:
+  -
+    name: master
+    private_networks: [ {auto_network: true} ]
+    box: centos-5-i386
+    roles: puppetmaster
+  -
+    name: agent
+    private_networks: [ {auto_network: true} ]
+    box: centos-5-i386
+    roles: puppetagent

data/lib/config_builder.rb

@@ -0,0 +1,24 @@
+require 'vagrant'
+
+module ConfigBuilder
+  require 'config_builder/loader'
+  require 'config_builder/model'
+  require 'config_builder/runner'
+  require 'config_builder/plugin'
+  require 'config_builder/version'
+
+  def self.load(identifier, method, value)
+    runner = ConfigBuilder::Runner.new
+    runner.run(identifier, method, value)
+  end
+
+  def self.source_root
+    @source_root ||= File.expand_path('..', __FILE__)
+  end
+
+  def self.template_root
+    @template_root ||= File.expand_path('../templates', source_root)
+  end
+end
+
+I18n.load_path << File.join(ConfigBuilder.template_root, 'locales/en.yml')

data/lib/config_builder/action/load_extensions.rb

@@ -0,0 +1,14 @@
+module ConfigBuilder
+  module Action
+    class LoadExtensions
+      def initialize(app, env)
+        @app, @env = app, env
+      end
+
+      def call(hash)
+        hash[:env].hook(:config_builder_extension)
+        @app.call(hash)
+      end
+    end
+  end
+end

data/lib/config_builder/class_registry.rb

@@ -0,0 +1,72 @@
+require 'vagrant/errors'
+
+module ConfigBuilder
+
+  # This defines a registry for classes, and behaves as a factory for registered classes.
+  #
+  # @api private
+  class ClassRegistry
+
+    class UnknownEntry < Vagrant::Errors::VagrantError
+      error_key('unknown_entry', 'config_builder.class_registry')
+    end
+
+    class DuplicateEntry < Vagrant::Errors::VagrantError
+      error_key('duplicate_entry', 'config_builder.class_registry')
+    end
+
+    def initialize(name)
+      @name    = name
+      @klasses = {}
+    end
+
+    # Register a class with a given identifier
+    #
+    # @param identifier [Symbol]
+    # @param klass [Class]
+    #
+    # @return [void]
+    def register(identifier, klass)
+      if @klasses[identifier]
+        raise DuplicateEntry, :registry => @name,
+                              :identifier => identifier.inspect
+      else
+        @klasses[identifier] = klass
+      end
+    end
+
+    # Retrieve a class associated with the specified identifier
+    #
+    # @param identifier [Symbol]
+    #
+    # @return [Class]
+    def retrieve(identifier)
+      if (klass = @klasses[identifier])
+        klass
+      else
+        raise UnknownEntry, :registry  => @name,
+                            :identifier => identifier.inspect,
+                            :identifiers => @klasses.keys
+      end
+    end
+
+    # Generate a class instance with the given hash
+    #
+    # @param hash [Hash] The identifier and options for the new object
+    # @option hash type [String] The identifier of the class to instantiate
+    #
+    # @return [Object] The generated object
+    def generate(hash)
+      config = hash.dup
+      identifier = config.delete('type')
+
+      klass = retrieve(identifier)
+
+      klass.new_from_hash(hash)
+    end
+
+    def inspect
+      "<#{self.class}: (#{@name}) keys: #{@klasses.keys.inspect}>"
+    end
+  end
+end

data/lib/config_builder/extension_handler.rb

@@ -0,0 +1,22 @@
+module ConfigBuilder
+  # Welcome to hell.
+  # @api private
+  class ExtensionHandler
+    def initialize
+      @logger = Log4r::Logger.new('vagrant::config_builder::extension_handler')
+    end
+
+    def load_from_plugins
+      Vagrant.plugin('2').manager.registered.each do |plugin|
+        load_plugin(plugin)
+      end
+    end
+
+    def load_plugin(plugin)
+      if plugin.respond_to? :config_builder_hook
+        @logger.info "Loading config_builder extension #{plugin.inspect}"
+        plugin.config_builder_hook
+      end
+    end
+  end
+end

data/lib/config_builder/filter.rb

@@ -0,0 +1,6 @@
+module ConfigBuilder
+  module Filter
+    require 'config_builder/filter/roles'
+    require 'config_builder/filter/boxes'
+  end
+end

data/lib/config_builder/filter/boxes.rb

@@ -0,0 +1,22 @@
+class ConfigBuilder::Filter::Boxes
+
+  attr_reader :boxes
+
+  def set_config(root_config)
+    @root_config = root_config
+    @boxes       = (@root_config.delete('boxes') || {})
+  end
+
+  def run
+    return @root_config if @root_config['vms'].nil?
+
+    @root_config['vms'].each { |vm_hash| filter_vm(vm_hash) }
+    @root_config
+  end
+
+  def filter_vm(vm_hash)
+    if (box_name = vm_hash['box'])
+      vm_hash['box_url'] ||= @boxes[box_name]
+    end
+  end
+end

data/lib/config_builder/filter/roles.rb

@@ -0,0 +1,149 @@
+# The 'roles' filter adds a mechanism for defining generic VM roles and
+# applying them to VMs.
+#
+# Defining roles
+# --------------
+#
+# This filter adds support for a top level `roles` key. It contains a hash of
+# role names that define a hash containing the role behavior.
+#
+# @note: The 'vms' field is of type Array, while the 'roles' field is of type
+# Hash. This is because order of declaration matters for the actual VMs, while
+# the order of declaration of roles does not matter.
+#
+# @example
+#   >> run()
+#   =>  {
+#         'roles' => {
+#           'webserver' => {
+#             'synced_folders' => [
+#               {'host_path' => './www',                'guest_path' => '/var/www'},
+#               {'host_path' => './webserver-binaries', 'guest_path' => '/opt/webserver-binaries'},
+#             ]
+#           },
+#           'database' => {
+#             'provisioners' => [
+#               {'type' => 'puppet', 'manifest' => 'dbserver.pp'},
+#               {'type' => 'shell',  'path'     => 'scripts/initialize-db.sh'},
+#             ],
+#           }
+#         },
+#         'vms' => [
+#           {'name' => 'web',        'roles' => 'webserver'},
+#           {'name' => 'db',         'roles' => 'database'},
+#           {'name' => 'standalone', 'roles' => ['webserver', 'database']},
+#         ],
+#       }
+#
+class ConfigBuilder::Filter::Roles
+
+  # @!attribute [r] roles
+  #   @return [Hash<String, Object>]
+  attr_reader :roles
+
+  def set_config(root_config)
+    @root_config = root_config
+    @roles       = @root_config.delete('roles')
+    @vms         = @root_config.delete('vms')
+  end
+
+  def run
+    return @root_config if @vms.nil?
+
+    @root_config['vms'] = @vms.map { |vm_hash| filter_vm(vm_hash) }
+    @root_config
+  end
+
+  # @param old_vm [Hash]
+  #
+  # @return [Hash] The filtered VM
+  def filter_vm(old_vm)
+    role_list  = old_vm.delete('roles')
+    node_stack = roles_by_name(role_list)
+
+    node_stack << old_vm
+
+    new_vm = node_stack.inject({}) do |accumulator, role|
+      merge_nodes(accumulator, role)
+    end
+
+    new_vm
+  end
+
+  # Fetch the role associated with the given name
+  #
+  # @param name [String]
+  #
+  # @return [Hash<String, Object>]
+  def role(name)
+    if (retval = @roles[name])
+      retval
+    else
+      raise ArgumentError, "Requested role #{name.inspect} is not defined, available roles: #{@roles.keys}."
+    end
+  end
+
+  # @overload roles_by_name(name)
+  #   @param name [String] A single role name
+  #   @return [Array<Hash>] An array containing the requested role
+  #
+  # @overload roles_by_name(names)
+  #   @param names [Array<String>] A list of role names
+  #   @return [Array<Hash>] An array containing all of the requested roles in the
+  #                         order requested.
+  #
+  # @overload roles_by_name(nothing)
+  #   @param nothing [NilClass] nil
+  #   @return [Array<>] An empty array
+  #
+  # @return [Array]
+  def roles_by_name(field)
+
+    case field
+    when Array    then names = field
+    when String   then names = [field]
+    when NilClass then names = []
+    end
+
+    names.map { |name| role(name) }
+  end
+
+  private
+
+  # Merge two node hash structures, with values in `right` overwriting values
+  # in `left`.
+  #
+  # @param left  [Hash]
+  # @param right [Hash]
+  #
+  # @return [Hash]
+  def merge_nodes(left, right)
+    retval = right.clone
+
+    array_keys = %w[
+      providers
+      provisioners
+      synced_folders
+      forwarded_ports
+      private_networks
+      public_networks
+      guest
+    ]
+
+    array_keys.each do |key|
+      if (left[key] and right[key])
+        retval[key] += left[key]
+      elsif left[key]
+        retval[key] = left[key].clone
+      end
+    end
+
+    single_keys = %w[provider box name communicator]
+
+    single_keys.each do |key|
+      retval[key] = left[key] if left[key]
+    end
+
+    retval
+  end
+end

data/lib/config_builder/filter_stack.rb

@@ -0,0 +1,37 @@
+require 'config_builder/filter'
+
+module ConfigBuilder
+  class FilterStack
+
+    def initialize
+      @filter_stack = []
+    end
+
+    # @param input [Hash]
+    #
+    # @return [Hash]
+    def filter(input)
+      set_filters(input.delete(:filters))
+
+      output = @filter_stack.inject(input) do |current_input, filter|
+        filter.set_config(current_input)
+        filter.run
+      end
+
+      output
+    end
+
+    private
+
+    # @note The implementation of this method is not final, use at your own peril.
+    # @api private
+    def set_filters(list)
+      if list.nil?
+        @filter_stack << ConfigBuilder::Filter::Roles.new
+        @filter_stack << ConfigBuilder::Filter::Boxes.new
+      else
+        @filter_stack = list
+      end
+    end
+  end
+end

data/lib/config_builder/loader.rb

@@ -0,0 +1,23 @@
+require 'config_builder/class_registry'
+
+module ConfigBuilder
+  module Loader
+    @registry = ConfigBuilder::ClassRegistry.new(:loader)
+
+    def self.register(identifier, klass)
+      @registry.register(identifier, klass)
+    end
+
+    def self.retrieve(identifier)
+      @registry.retrieve(identifier)
+    end
+
+    def self.generate(identifier, method_name, method_value)
+      obj = retrieve(identifier).new
+      obj.send(method_name, method_value)
+    end
+
+    require 'config_builder/loader/yaml'
+    require 'config_builder/loader/yaml_erb'
+  end
+end

data/lib/config_builder/loader/yaml.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+require 'deep_merge/core'
+
+class ConfigBuilder::Loader::YAML
+
+  # Load configuration from YAML files in one or more directories
+  #
+  # @overload yamldir(path)
+  #   @param path [String] A directory path containing YAML files
+  # @overload yamldir(paths)
+  #   @param paths [Array<String>] A list of directory paths containing YAML files
+  #
+  # @return [Hash]
+  def yamldir(input)
+    dirs = Array(input)
+
+    files = dirs.map do |dir|
+      pattern = File.join(dir, '*.{yml,yaml}')
+      Dir.glob(pattern)
+    end.flatten
+
+    rv = {}
+
+    files.each do |file|
+      contents = yamlfile(file)
+      if contents.is_a? Hash
+        rv = DeepMerge::deep_merge!(contents, rv, {:preserve_unmergables => false})
+      end
+    end
+
+    rv
+  end
+
+  # Load configuration from a file
+  #
+  # @param file_path [String]
+  #
+  # @return [Hash]
+  def yamlfile(file_path)
+    ::YAML.load_file(file_path)
+  end
+
+  ConfigBuilder::Loader.register(:yaml, self)
+end