tnargav 1.3.5 → 1.3.6

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

@@ -0,0 +1,66 @@
+require File.expand_path("../base", __FILE__)
+
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module Chef
+    module Config
+      class ChefClient < Base
+        attr_accessor :chef_server_url
+        attr_accessor :client_key_path
+        attr_accessor :delete_client
+        attr_accessor :delete_node
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+        attr_accessor :environment
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+
+        def initialize
+          super
+
+          @chef_server_url                    = UNSET_VALUE
+          @client_key_path                    = UNSET_VALUE
+          @delete_client                      = UNSET_VALUE
+          @delete_node                        = UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = UNSET_VALUE
+          @encrypted_data_bag_secret          = UNSET_VALUE
+          @environment                        = UNSET_VALUE
+          @validation_key_path                = UNSET_VALUE
+          @validation_client_name             = UNSET_VALUE
+        end
+
+        def finalize!
+          super
+
+          @chef_server_url = nil if @chef_server_url == UNSET_VALUE
+          @client_key_path        = "/etc/chef/client.pem" if @client_key_path == UNSET_VALUE
+          @delete_client = false if @delete_client == UNSET_VALUE
+          @delete_node = false if @delete_node == UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = nil if @encrypted_data_bag_secret_key_path == UNSET_VALUE
+          @encrypted_data_bag_secret          = "/tmp/encrypted_data_bag_secret" if @encrypted_data_bag_secret == UNSET_VALUE
+          @environment = nil if @environment == UNSET_VALUE
+          @validation_client_name = "chef-validator" if @validation_client_name == UNSET_VALUE
+          @validation_key_path = nil if @validation_key_path == UNSET_VALUE
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+          errors.concat(validate_base(machine))
+          errors << I18n.t("vagrant.config.chef.server_url_empty") if \
+            !chef_server_url || chef_server_url.strip == ""
+          errors << I18n.t("vagrant.config.chef.validation_key_path") if \
+            !validation_key_path
+
+          if delete_client || delete_node
+            if !Vagrant::Util::Which.which("knife")
+              errors << I18n.t("vagrant.chef_config_knife_not_found")
+            end
+          end
+
+          { "chef client provisioner" => errors }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Chef
+    module Config
+      class ChefSolo < Base
+        attr_accessor :cookbooks_path
+        attr_accessor :roles_path
+        attr_accessor :data_bags_path
+        attr_accessor :recipe_url
+        attr_accessor :nfs
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+        attr_accessor :environments_path
+        attr_accessor :environment
+
+        def initialize
+          super
+
+          @cookbooks_path            = UNSET_VALUE
+          @data_bags_path            = UNSET_VALUE
+          @environments_path         = UNSET_VALUE
+          @environment               = UNSET_VALUE
+          @recipe_url                = UNSET_VALUE
+          @roles_path                = UNSET_VALUE
+          @nfs                       = UNSET_VALUE
+          @encrypted_data_bag_secret = UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = UNSET_VALUE
+        end
+
+        #------------------------------------------------------------
+        # Internal methods
+        #------------------------------------------------------------
+
+        def finalize!
+          super
+
+          @recipe_url = nil if @recipe_url == UNSET_VALUE
+          @environment = nil if @environment == UNSET_VALUE
+
+          if @cookbooks_path == UNSET_VALUE
+            @cookbooks_path = []
+            @cookbooks_path << [:host, "cookbooks"] if !@recipe_url
+            @cookbooks_path << [:vm, "cookbooks"]
+          end
+
+          @data_bags_path    = [] if @data_bags_path == UNSET_VALUE
+          @roles_path        = [] if @roles_path == UNSET_VALUE
+          @environments_path = [] if @environments_path == UNSET_VALUE
+          @environments_path = [@environments_path].flatten
+
+          # Make sure the path is an array.
+          @cookbooks_path    = prepare_folders_config(@cookbooks_path)
+          @data_bags_path    = prepare_folders_config(@data_bags_path)
+          @roles_path        = prepare_folders_config(@roles_path)
+          @environments_path = prepare_folders_config(@environments_path)
+
+          @nfs = false if @nfs == UNSET_VALUE
+          @encrypted_data_bag_secret = "/tmp/encrypted_data_bag_secret" if \
+            @encrypted_data_bag_secret == UNSET_VALUE
+          @encrypted_data_bag_secret_key_path = nil if \
+            @encrypted_data_bag_secret_key_path == UNSET_VALUE
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+          errors.concat(validate_base(machine))
+          errors << I18n.t("vagrant.config.chef.cookbooks_path_empty") if \
+            !cookbooks_path || [cookbooks_path].flatten.empty?
+          errors << I18n.t("vagrant.config.chef.environment_path_required") if \
+            environment && environments_path.empty?
+          { "chef solo provisioner" => errors }
+        end
+
+        protected
+
+        # This takes any of the configurations that take a path or
+        # array of paths and turns it into the proper format.
+        #
+        # @return [Array]
+        def prepare_folders_config(config)
+          # Make sure the path is an array
+          config = [config] if !config.is_a?(Array) || config.first.is_a?(Symbol)
+
+          # Make sure all the paths are in the proper format
+          config.map do |path|
+            path = [:host, path] if !path.is_a?(Array)
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/chef/plugin.rb

@@ -0,0 +1,33 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Chef
+    class Plugin < Vagrant.plugin("2")
+      name "chef"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Chef via `chef-solo` or `chef-client`.
+      DESC
+
+      config(:chef_solo, :provisioner) do
+        require File.expand_path("../config/chef_solo", __FILE__)
+        Config::ChefSolo
+      end
+
+      config(:chef_client, :provisioner) do
+        require File.expand_path("../config/chef_client", __FILE__)
+        Config::ChefClient
+      end
+
+      provisioner(:chef_solo)   do
+        require File.expand_path("../provisioner/chef_solo", __FILE__)
+        Provisioner::ChefSolo
+      end
+
+      provisioner(:chef_client) do
+        require File.expand_path("../provisioner/chef_client", __FILE__)
+        Provisioner::ChefClient
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+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.ssh_info[:username]} #{@config.provisioning_path}")
+          end
+        end
+
+        def setup_config(template, filename, template_vars)
+          # If we have custom configuration, upload it
+          remote_custom_config_path = nil
+          if @config.custom_config_path
+            expanded = File.expand_path(
+              @config.custom_config_path, @machine.env.root_path)
+            remote_custom_config_path = File.join(
+              config.provisioning_path, "custom-config.rb")
+
+            @machine.communicate.upload(expanded, remote_custom_config_path)
+          end
+
+          config_file = Vagrant::Util::TemplateRenderer.render(template, {
+            :custom_configuration => remote_custom_config_path,
+            :file_cache_path => @config.file_cache_path,
+            :file_backup_path => @config.file_backup_path,
+            :log_level        => @config.log_level.to_sym,
+            :verbose_logging  => @config.verbose_logging,
+            :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,
+            :formatter        => @config.formatter
+          }.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 = @config.json
+          json[:run_list] = @config.run_list if !@config.run_list.empty?
+          json = JSON.pretty_generate(json)
+
+          # Create a temporary file to store the data so we
+          # can upload it
+          temp = Tempfile.new("vagrant")
+          temp.write(json)
+          temp.close
+
+          remote_file = File.join(@config.provisioning_path, "dna.json")
+          @machine.communicate.tap do |comm|
+            comm.sudo("rm #{remote_file}", :error_check => false)
+            comm.upload(temp.path, remote_file)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'pathname'
+require 'vagrant/util/subprocess'
+
+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 cleanup
+          delete_from_chef_server('client') if config.delete_client
+          delete_from_chef_server('node') if config.delete_node
+        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,
+            :environment => @config.environment,
+            :encrypted_data_bag_secret => @config.encrypted_data_bag_secret
+          })
+        end
+
+        def run_chef_client
+          if @config.run_list && @config.run_list.empty?
+            @machine.ui.warn(I18n.t("vagrant.chef_run_list_empty"))
+          end
+
+          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
+              @machine.env.ui.info(
+                data, :color => color, :new_line => false, :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
+
+        def delete_from_chef_server(deletable)
+          node_name = config.node_name || env[:vm].config.vm.host_name
+          env[:ui].info(I18n.t(
+            "vagrant.provisioners.chef.deleting_from_server",
+            deletable: deletable, name: node_name))
+
+          command = ["knife", deletable, "delete", "--yes", node_name]
+          r = Vagrant::Util::Subprocess.execute(*command)
+          if r.exit_code != 0
+            env[:ui].error(I18n.t(
+              "vagrant.chef_client_cleanup_failed",
+              deletable: deletable,
+              stdout: r.stdout,
+              stderr: r.stderr))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+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 :environments_folders
+        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")
+          @environments_folders = expanded_folders(@config.environments_path, "environments")
+
+          share_folders(root_config, "csc", @cookbook_folders)
+          share_folders(root_config, "csr", @role_folders)
+          share_folders(root_config, "csdb", @data_bags_folders)
+          share_folders(root_config, "cse", @environments_folders)
+        end
+
+        def provision
+          # Verify that the proper shared folders exist.
+          check = []
+          [@cookbook_folders, @role_folders, @data_bags_folders, @environments_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
+
+          chown_provisioning_folder
+          verify_shared_folders(check)
+          verify_binary(chef_binary_path("chef-solo"))
+          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)
+
+              if File.exist?(local_path)
+                # Path exists on the host, setup the remote path
+                remote_path = "#{@config.provisioning_path}/chef-solo-#{get_and_update_counter(:cookbooks_path)}"
+              else
+                @machine.ui.warn(I18n.t("vagrant.provisioners.chef.cookbook_folder_not_found_warning",
+                                       path: local_path.to_s))
+                next
+              end
+            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.tap do |comm|
+            comm.sudo("rm #{@config.encrypted_data_bag_secret}", :error_check => false)
+            comm.upload(encrypted_data_bag_secret_key_path,
+                        @config.encrypted_data_bag_secret)
+          end
+        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
+          environments_path = guest_paths(@environments_folders).first
+          setup_config("provisioners/chef_solo/solo", "solo.rb", {
+            :node_name => @config.node_name,
+            :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,
+            :environments_path => environments_path,
+            :environment => @config.environment,
+          })
+        end
+
+        def run_chef_solo
+          if @config.run_list && @config.run_list.empty?
+            @machine.ui.warn(I18n.t("vagrant.chef_run_list_empty"))
+          end
+
+          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
+              @machine.env.ui.info(
+                data, :color => color, :new_line => false, :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}", sudo: true)
+              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