tnargav 1.3.5 → 1.3.6

data/plugins/provisioners/file/config.rb

@@ -0,0 +1,29 @@
+require "vagrant"
+
+module VagrantPlugins
+  module FileUpload
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :source
+      attr_accessor :destination
+
+      def validate(machine)
+        errors = _detected_errors
+        if !source
+          errors << I18n.t("vagrant.provisioners.file.no_source_file")
+        end
+        if !destination
+          errors << I18n.t("vagrant.provisioners.file.no_dest_file")
+        end
+        if source
+          s = File.expand_path(source)
+          if ! File.exist?(s)
+            errors << I18n.t("vagrant.provisioners.file.path_invalid",
+                              :path => s)
+          end
+        end
+
+        { "File provisioner" => errors }
+      end
+    end
+  end
+end

data/plugins/provisioners/file/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module FileUpload
+    class Plugin < Vagrant.plugin("2")
+      name "file"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      uploaded files.
+      DESC
+
+      config(:file, :provisioner) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      provisioner(:file) do
+        require File.expand_path("../provisioner", __FILE__)
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/file/provisioner.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module FileUpload
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        @machine.communicate.tap do |comm|
+          # Make sure the remote path exists
+          command = "mkdir -p %s" % File.dirname(config.destination)
+          comm.execute(command) 
+
+          # now upload the file
+          comm.upload(File.expand_path(config.source), config.destination)
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/config/puppet.rb

@@ -0,0 +1,93 @@
+module VagrantPlugins
+  module Puppet
+    module Config
+      class Puppet < Vagrant.plugin("2", :config)
+        attr_accessor :facter
+        attr_accessor :hiera_config_path
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :options
+        attr_accessor :temp_dir
+        attr_accessor :working_directory
+        attr_accessor :nfs
+
+        def initialize
+          super
+
+          @hiera_config_path = UNSET_VALUE
+          @manifest_file     = UNSET_VALUE
+          @manifests_path    = UNSET_VALUE
+          @module_path       = UNSET_VALUE
+          @options           = []
+          @facter            = {}
+          @temp_dir          = UNSET_VALUE
+          @working_directory = UNSET_VALUE
+          @nfs               = UNSET_VALUE
+        end
+
+        def finalize!
+          super
+
+          @hiera_config_path = nil if @hiera_config_path == UNSET_VALUE
+          @manifest_file  = "default.pp" if @manifest_file == UNSET_VALUE
+          @manifests_path = "manifests" if @manifests_path == UNSET_VALUE
+          @module_path    = nil if @module_path == UNSET_VALUE
+          @temp_dir       = "/tmp/vagrant-puppet" if @temp_dir == UNSET_VALUE
+          @working_directory = nil if @working_directory == UNSET_VALUE
+          @nfs            = false if @nfs == UNSET_VALUE
+        end
+
+        # Returns the manifests path expanded relative to the root path of the
+        # environment.
+        def expanded_manifests_path(root_path)
+          Pathname.new(manifests_path).expand_path(root_path)
+        end
+
+        # Returns the module paths as an array of paths expanded relative to the
+        # root path.
+        def expanded_module_paths(root_path)
+          return [] if !module_path
+
+          # Get all the paths and expand them relative to the root path, returning
+          # the array of expanded paths
+          paths = module_path
+          paths = [paths] if !paths.is_a?(Array)
+          paths.map do |path|
+            Pathname.new(path).expand_path(root_path)
+          end
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+
+          # Calculate the manifests and module paths based on env
+          this_expanded_manifests_path = expanded_manifests_path(machine.env.root_path)
+          this_expanded_module_paths = expanded_module_paths(machine.env.root_path)
+
+          # Manifests path/file validation
+          if !this_expanded_manifests_path.directory?
+            errors << I18n.t("vagrant.provisioners.puppet.manifests_path_missing",
+                             :path => this_expanded_manifests_path)
+          else
+            expanded_manifest_file = this_expanded_manifests_path.join(manifest_file)
+            if !expanded_manifest_file.file?
+              errors << I18n.t("vagrant.provisioners.puppet.manifest_missing",
+                               :manifest => expanded_manifest_file.to_s)
+            end
+          end
+
+          # Module paths validation
+          this_expanded_module_paths.each do |path|
+            if !path.directory?
+              errors << I18n.t("vagrant.provisioners.puppet.module_path_missing",
+                               :path => path)
+            end
+          end
+
+          { "puppet provisioner" => errors }
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/config/puppet_server.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Puppet
+    module Config
+      class PuppetServer < Vagrant.plugin("2", :config)
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+        attr_accessor :facter
+
+        def facter; @facter ||= {}; end
+        def puppet_server; @puppet_server || "puppet"; end
+        def options; @options ||= []; end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/plugin.rb

@@ -0,0 +1,33 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Puppet
+    class Plugin < Vagrant.plugin("2")
+      name "puppet"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Puppet either using `puppet apply` or a Puppet server.
+      DESC
+
+      config(:puppet, :provisioner) do
+        require File.expand_path("../config/puppet", __FILE__)
+        Config::Puppet
+      end
+
+      config(:puppet_server, :provisioner) do
+        require File.expand_path("../config/puppet_server", __FILE__)
+        Config::PuppetServer
+      end
+
+      provisioner(:puppet) do
+        require File.expand_path("../provisioner/puppet", __FILE__)
+        Provisioner::Puppet
+      end
+
+      provisioner(:puppet_server) do
+        require File.expand_path("../provisioner/puppet_server", __FILE__)
+        Provisioner::PuppetServer
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet.rb

@@ -0,0 +1,146 @@
+require "log4r"
+
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet")
+      end
+
+      class Puppet < Vagrant.plugin("2", :provisioner)
+        def initialize(machine, config)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
+        end
+
+        def configure(root_config)
+          # Calculate the paths we're going to use based on the environment
+          root_path = @machine.env.root_path
+          @expanded_manifests_path = @config.expanded_manifests_path(root_path)
+          @expanded_module_paths   = @config.expanded_module_paths(root_path)
+          @manifest_file           = File.join(manifests_guest_path, @config.manifest_file)
+
+          # Setup the module paths
+          @module_paths = []
+          @expanded_module_paths.each_with_index do |path, i|
+            @module_paths << [path, File.join(config.temp_dir, "modules-#{i}")]
+          end
+
+          folder_opts = {}
+          folder_opts[:nfs] = true if @config.nfs
+          folder_opts[:owner] = "root" if !folder_opts[:nfs]
+
+          # Share the manifests directory with the guest
+          root_config.vm.synced_folder(
+            @expanded_manifests_path, manifests_guest_path, folder_opts)
+
+          # Share the module paths
+          @module_paths.each do |from, to|
+            root_config.vm.synced_folder(from, to, folder_opts)
+          end
+        end
+
+        def provision
+          # Check that the shared folders are properly shared
+          check = [manifests_guest_path]
+          @module_paths.each do |host_path, guest_path|
+            check << guest_path
+          end
+
+          verify_shared_folders(check)
+
+          # Verify Puppet is installed and run it
+          verify_binary("puppet")
+
+          # Make sure the temporary directory is properly set up
+          @machine.communicate.tap do |comm|
+            comm.sudo("mkdir -p #{config.temp_dir}")
+            comm.sudo("chmod 0777 #{config.temp_dir}")
+          end
+
+          # Upload Hiera configuration if we have it
+          @hiera_config_path = nil
+          if config.hiera_config_path
+            local_hiera_path   = File.expand_path(config.hiera_config_path, @machine.env.root_path)
+            @hiera_config_path = File.join(config.temp_dir, "hiera.yaml")
+            @machine.communicate.upload(local_hiera_path, @hiera_config_path)
+          end
+
+          run_puppet_apply
+        end
+
+        def manifests_guest_path
+          File.join(config.temp_dir, "manifests")
+        end
+
+        def verify_binary(binary)
+          @machine.communicate.sudo(
+            "which #{binary}",
+            :error_class => PuppetError,
+            :error_key => :not_detected,
+            :binary => binary)
+        end
+
+        def run_puppet_apply
+          options = [config.options].flatten
+          module_paths = @module_paths.map { |_, to| to }
+          if !@module_paths.empty?
+            # Prepend the default module path
+            module_paths.unshift("/etc/puppet/modules")
+
+            # Add the command line switch to add the module path
+            options << "--modulepath '#{module_paths.join(':')}'"
+          end
+
+          if @hiera_config_path
+            options << "--hiera_config=#{@hiera_config_path}"
+          end
+
+          if !@machine.env.ui.is_a?(Vagrant::UI::Colored)
+            options << "--color=false"
+          end
+
+          options << "--manifestdir #{manifests_guest_path}"
+          options << "--detailed-exitcodes"
+          options << @manifest_file
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = ""
+          if !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "FACTER_#{key}='#{value}'"
+            end
+
+            facter = "#{facts.join(" ")} "
+          end
+
+          command = "#{facter}puppet apply #{options} || [ $? -eq 2 ]"
+          if config.working_directory
+            command = "cd #{config.working_directory} && #{command}"
+          end
+
+          @machine.env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet",
+                                      :manifest => config.manifest_file)
+
+          @machine.communicate.sudo(command) do |type, data|
+            if !data.empty?
+              @machine.env.ui.info(data, :new_line => false, :prefix => false)
+            end
+          end
+        end
+
+        def verify_shared_folders(folders)
+          folders.each do |folder|
+            @logger.debug("Checking for shared folder: #{folder}")
+            if !@machine.communicate.test("test -d #{folder}", sudo: true)
+              raise PuppetError, :missing_shared_folders
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet_server.rb

@@ -0,0 +1,74 @@
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetServerError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet_server")
+      end
+
+      class PuppetServer < Vagrant.plugin("2", :provisioner)
+        def provision
+          verify_binary("puppet")
+          run_puppet_agent
+        end
+
+        def verify_binary(binary)
+          @machine.communicate.sudo(
+            "which #{binary}",
+            :error_class => PuppetServerError,
+            :error_key => :not_detected,
+            :binary => binary)
+        end
+
+        def run_puppet_agent
+          options = config.options
+          options = [options] if !options.is_a?(Array)
+
+          # Intelligently set the puppet node cert name based on certain
+          # external parameters.
+          cn = nil
+          if config.puppet_node
+            # If a node name is given, we use that directly for the certname
+            cn = config.puppet_node
+          elsif @machine.config.vm.hostname
+            # If a host name is given, we explicitly set the certname to
+            # nil so that the hostname becomes the cert name.
+            cn = nil
+          else
+            # Otherwise, we default to the name of the box.
+            cn = @machine.config.vm.box
+          end
+
+          # Add the certname option if there is one
+          options += ["--certname", cn] if cn
+
+          # Disable colors if we must
+          if !@machine.env.ui.is_a?(Vagrant::UI::Colored)
+            options << "--color=false"
+          end
+
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = ""
+          if !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "FACTER_#{key}='#{value}'"
+            end
+
+            facter = "#{facts.join(" ")} "
+          end
+
+          command = "#{facter}puppet agent #{options} --server #{config.puppet_server} --detailed-exitcodes || [ $? -eq 2 ]"
+
+          @machine.env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+          @machine.communicate.sudo(command) do |type, data|
+            if !data.empty?
+              @machine.env.ui.info(data, :new_line => false, :prefix => false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/salt/bootstrap-salt.sh

@@ -0,0 +1,6 @@
+#!/bin/sh -
+
+# We just download the bootstrap script by default and execute that.
+python \
+    -c 'import urllib; print urllib.urlopen("http://bootstrap.saltstack.org").read()' \
+    | sh -s -- "$@"