vagrantup 1.0.7 → 1.1.0

data/plugins/provisioners/chef/provisioner/base.rb

@@ -0,0 +1,91 @@
+require 'tempfile'
+
+require "vagrant/util/counter"
+require "vagrant/util/template_renderer"
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      # This class is a base class where the common functionality shared between
+      # chef-solo and chef-client provisioning are stored. This is **not an actual
+      # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+      class Base < Vagrant.plugin("2", :provisioner)
+        class ChefError < Vagrant::Errors::VagrantError
+          error_namespace("vagrant.provisioners.chef")
+        end
+
+        include Vagrant::Util::Counter
+
+        def initialize(machine, config)
+          super
+
+          config.provisioning_path ||= "/tmp/vagrant-chef-#{get_and_update_counter(:provisioning_path)}"
+        end
+
+        def verify_binary(binary)
+          # Checks for the existence of chef binary and error if it
+          # doesn't exist.
+          @machine.communicate.sudo(
+            "which #{binary}",
+            :error_class => ChefError,
+            :error_key => :chef_not_detected,
+            :binary => binary)
+        end
+
+        # Returns the path to the Chef binary, taking into account the
+        # `binary_path` configuration option.
+        def chef_binary_path(binary)
+          return binary if !@config.binary_path
+          return File.join(@config.binary_path, binary)
+        end
+
+        def chown_provisioning_folder
+          @machine.communicate.tap do |comm|
+            comm.sudo("mkdir -p #{@config.provisioning_path}")
+            comm.sudo("chown #{@machine.config.ssh.username} #{@config.provisioning_path}")
+          end
+        end
+
+        def setup_config(template, filename, template_vars)
+          config_file = Vagrant::Util::TemplateRenderer.render(template, {
+            :log_level        => @config.log_level.to_sym,
+            :http_proxy       => @config.http_proxy,
+            :http_proxy_user  => @config.http_proxy_user,
+            :http_proxy_pass  => @config.http_proxy_pass,
+            :https_proxy      => @config.https_proxy,
+            :https_proxy_user => @config.https_proxy_user,
+            :https_proxy_pass => @config.https_proxy_pass,
+            :no_proxy         => @config.no_proxy
+          }.merge(template_vars))
+
+          # Create a temporary file to store the data so we
+          # can upload it
+          temp = Tempfile.new("vagrant")
+          temp.write(config_file)
+          temp.close
+
+          remote_file = File.join(config.provisioning_path, filename)
+          @machine.communicate.tap do |comm|
+            comm.sudo("rm #{remote_file}", :error_check => false)
+            comm.upload(temp.path, remote_file)
+          end
+        end
+
+        def setup_json
+          @machine.env.ui.info I18n.t("vagrant.provisioners.chef.json")
+
+          # Get the JSON that we're going to expose to Chef
+          json = JSON.pretty_generate(@config.merged_json)
+
+          # Create a temporary file to store the data so we
+          # can upload it
+          temp = Tempfile.new("vagrant")
+          temp.write(json)
+          temp.close
+
+          @machine.communicate.upload(temp.path, File.join(@config.provisioning_path, "dna.json"))
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/chef/provisioner/chef_client.rb

@@ -0,0 +1,103 @@
+require 'pathname'
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      # This class implements provisioning via chef-client, allowing provisioning
+      # with a chef server.
+      class ChefClient < Base
+        def configure(root_config)
+          raise ChefError, :server_validation_key_required if @config.validation_key_path.nil?
+          raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
+          raise ChefError, :server_url_required if @config.chef_server_url.nil?
+        end
+
+        def provision
+          verify_binary(chef_binary_path("chef-client"))
+          chown_provisioning_folder
+          create_client_key_folder
+          upload_validation_key
+          upload_encrypted_data_bag_secret if @config.encrypted_data_bag_secret_key_path
+          setup_json
+          setup_server_config
+          run_chef_client
+        end
+
+        def create_client_key_folder
+          @machine.env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
+          path = Pathname.new(@config.client_key_path)
+
+          @machine.communicate.sudo("mkdir -p #{path.dirname}")
+        end
+
+        def upload_validation_key
+          @machine.env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
+          @machine.communicate.upload(validation_key_path, guest_validation_key_path)
+        end
+
+        def upload_encrypted_data_bag_secret
+          @machine.env.ui.info I18n.t("vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
+          @machine.communicate.upload(encrypted_data_bag_secret_key_path,
+                                  @config.encrypted_data_bag_secret)
+        end
+
+        def setup_server_config
+          setup_config("provisioners/chef_client/client", "client.rb", {
+            :node_name => @config.node_name,
+            :chef_server_url => @config.chef_server_url,
+            :validation_client_name => @config.validation_client_name,
+            :validation_key => guest_validation_key_path,
+            :client_key => @config.client_key_path,
+            :file_cache_path => @config.file_cache_path,
+            :file_backup_path => @config.file_backup_path,
+            :environment => @config.environment,
+            :encrypted_data_bag_secret => @config.encrypted_data_bag_secret
+          })
+        end
+
+        def run_chef_client
+          command_env = @config.binary_env ? "#{@config.binary_env} " : ""
+          command_args = @config.arguments ? " #{@config.arguments}" : ""
+          command = "#{command_env}#{chef_binary_path("chef-client")} -c #{@config.provisioning_path}/client.rb -j #{@config.provisioning_path}/dna.json #{command_args}"
+
+          @config.attempts.times do |attempt|
+            if attempt == 0
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
+            else
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_client_again")
+            end
+
+            exit_status = @machine.communicate.sudo(command, :error_check => false) do |type, data|
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              # Note: Be sure to chomp the data to avoid the newlines that the
+              # Chef outputs.
+              @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+            end
+
+            # There is no need to run Chef again if it converges
+            return if exit_status == 0
+          end
+
+          # If we reached this point then Chef never converged! Error.
+          raise ChefError, :no_convergence
+        end
+
+        def validation_key_path
+          File.expand_path(@config.validation_key_path, @machine.env.root_path)
+        end
+
+        def encrypted_data_bag_secret_key_path
+          File.expand_path(@config.encrypted_data_bag_secret_key_path, @machine.env.root_path)
+        end
+
+        def guest_validation_key_path
+          File.join(@config.provisioning_path, "validation.pem")
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/chef/provisioner/chef_solo.rb

@@ -0,0 +1,182 @@
+require "log4r"
+
+require "vagrant/util/counter"
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Provisioner
+      # This class implements provisioning via chef-solo.
+      class ChefSolo < Base
+        extend Vagrant::Util::Counter
+        include Vagrant::Util::Counter
+
+        attr_reader :cookbook_folders
+        attr_reader :role_folders
+        attr_reader :data_bags_folders
+
+        def initialize(machine, config)
+          super
+          @logger = Log4r::Logger.new("vagrant::provisioners::chef_solo")
+        end
+
+        def configure(root_config)
+          @cookbook_folders  = expanded_folders(@config.cookbooks_path, "cookbooks")
+          @role_folders      = expanded_folders(@config.roles_path, "roles")
+          @data_bags_folders = expanded_folders(@config.data_bags_path, "data_bags")
+
+          share_folders(root_config, "csc", @cookbook_folders)
+          share_folders(root_config, "csr", @role_folders)
+          share_folders(root_config, "csdb", @data_bags_folders)
+        end
+
+        def provision
+          # Verify that the proper shared folders exist.
+          check = []
+          [@cookbook_folders, @role_folders, @data_bags_folders].each do |folders|
+            folders.each do |type, local_path, remote_path|
+              # We only care about checking folders that have a local path, meaning
+              # they were shared from the local machine, rather than assumed to
+              # exist on the VM.
+              check << remote_path if local_path
+            end
+          end
+
+          verify_shared_folders(check)
+
+          verify_binary(chef_binary_path("chef-solo"))
+          chown_provisioning_folder
+          upload_encrypted_data_bag_secret if @config.encrypted_data_bag_secret_key_path
+          setup_json
+          setup_solo_config
+          run_chef_solo
+        end
+
+        # Converts paths to a list of properly expanded paths with types.
+        def expanded_folders(paths, appended_folder=nil)
+          # Convert the path to an array if it is a string or just a single
+          # path element which contains the folder location (:host or :vm)
+          paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+
+          results = []
+          paths.each do |type, path|
+            # Create the local/remote path based on whether this is a host
+            # or VM path.
+            local_path = nil
+            remote_path = nil
+            if type == :host
+              # Get the expanded path that the host path points to
+              local_path = File.expand_path(path, @machine.env.root_path)
+
+              # Path exists on the host, setup the remote path
+              remote_path = "#{@config.provisioning_path}/chef-solo-#{get_and_update_counter(:cookbooks_path)}"
+            else
+              # Path already exists on the virtual machine. Expand it
+              # relative to where we're provisioning.
+              remote_path = File.expand_path(path, @config.provisioning_path)
+
+              # Remove drive letter if running on a windows host. This is a bit
+              # of a hack but is the most portable way I can think of at the moment
+              # to achieve this. Otherwise, Vagrant attempts to share at some crazy
+              # path like /home/vagrant/c:/foo/bar
+              remote_path = remote_path.gsub(/^[a-zA-Z]:/, "")
+            end
+
+            # If we have specified a folder name to append then append it
+            remote_path += "/#{appended_folder}" if appended_folder
+
+            # Append the result
+            results << [type, local_path, remote_path]
+          end
+
+          results
+        end
+
+        # Shares the given folders with the given prefix. The folders should
+        # be of the structure resulting from the `expanded_folders` function.
+        def share_folders(root_config, prefix, folders)
+          folders.each do |type, local_path, remote_path|
+            if type == :host
+              root_config.vm.synced_folder(
+                local_path, remote_path,
+                :id =>  "v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
+                :nfs => @config.nfs)
+            end
+          end
+        end
+
+        def upload_encrypted_data_bag_secret
+          @machine.env.ui.info I18n.t("vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
+          @machine.communicate.upload(encrypted_data_bag_secret_key_path,
+                                           @config.encrypted_data_bag_secret)
+        end
+
+        def setup_solo_config
+          cookbooks_path = guest_paths(@cookbook_folders)
+          roles_path = guest_paths(@role_folders).first
+          data_bags_path = guest_paths(@data_bags_folders).first
+
+          setup_config("provisioners/chef_solo/solo", "solo.rb", {
+            :node_name => @config.node_name,
+            :provisioning_path => @config.provisioning_path,
+            :cookbooks_path => cookbooks_path,
+            :recipe_url => @config.recipe_url,
+            :roles_path => roles_path,
+            :data_bags_path => data_bags_path,
+            :encrypted_data_bag_secret => @config.encrypted_data_bag_secret,
+          })
+        end
+
+        def run_chef_solo
+          command_env = @config.binary_env ? "#{@config.binary_env} " : ""
+          command_args = @config.arguments ? " #{@config.arguments}" : ""
+          command = "#{command_env}#{chef_binary_path("chef-solo")} -c #{@config.provisioning_path}/solo.rb -j #{@config.provisioning_path}/dna.json #{command_args}"
+
+          @config.attempts.times do |attempt|
+            if attempt == 0
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
+            else
+              @machine.env.ui.info I18n.t("vagrant.provisioners.chef.running_solo_again")
+            end
+
+            exit_status = @machine.communicate.sudo(command, :error_check => false) do |type, data|
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              # Note: Be sure to chomp the data to avoid the newlines that the
+              # Chef outputs.
+              @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+            end
+
+            # There is no need to run Chef again if it converges
+            return if exit_status == 0
+          end
+
+          # If we reached this point then Chef never converged! Error.
+          raise ChefError, :no_convergence
+        end
+
+        def verify_shared_folders(folders)
+          folders.each do |folder|
+            @logger.debug("Checking for shared folder: #{folder}")
+            if !@machine.communicate.test("test -d #{folder}")
+              raise ChefError, :missing_shared_folders
+            end
+          end
+        end
+
+        def encrypted_data_bag_secret_key_path
+          File.expand_path(@config.encrypted_data_bag_secret_key_path, @machine.env.root_path)
+        end
+
+        protected
+
+        # Extracts only the remote paths from a list of folders
+        def guest_paths(folders)
+          folders.map { |parts| parts[2] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module VagrantPlugins
+  module Puppet
+    module Config
+      class Puppet < Vagrant.plugin("2", :config)
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :pp_path
+        attr_accessor :options
+        attr_accessor :facter
+
+        def manifest_file; @manifest_file || "default.pp"; end
+        def manifests_path; @manifests_path || "manifests"; end
+        def pp_path; @pp_path || "/tmp/vagrant-puppet"; end
+        def options; @options ||= []; end
+        def facter; @facter ||= {}; 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 = []
+
+          # 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