rvagrant 0.8.7.dev

data/lib/vagrant/provisioners/chef_client.rb

@@ -0,0 +1,120 @@
+require 'pathname'
+
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-client, allowing provisioning
+    # with a chef server.
+    class ChefClient < Chef
+      register :chef_client
+
+      class Config < Chef::Config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+        attr_accessor :file_cache_path
+        attr_accessor :file_backup_path
+        attr_accessor :environment
+        attr_accessor :encrypted_data_bag_secret_key_path
+        attr_accessor :encrypted_data_bag_secret
+
+        def initialize
+          super
+
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+          @file_cache_path = "/srv/chef/file_store"
+          @file_backup_path = "/srv/chef/cache"
+          @encrypted_data_bag_secret_key_path = nil
+          @encrypted_data_bag_secret = "/etc/chef/encrypted_data_bag_secret"
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
+          errors.add(I18n.t("vagrant.config.chef.validation_key_path")) if !validation_key_path
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if @run_list && @run_list.empty?
+        end
+      end
+
+      def prepare
+        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
+        env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
+        path = Pathname.new(config.client_key_path)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
+        vm.ssh.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def upload_encrypted_data_bag_secret
+        env.ui.info I18n.t("vagrant.provisioners.chef.upload_encrypted_data_bag_secret_key")
+        vm.ssh.upload!(encrypted_data_bag_secret_key_path, config.encrypted_data_bag_secret)
+      end
+
+      def setup_server_config
+        setup_config("chef_server_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 = "#{command_env}#{chef_binary_path("chef-client")} -c #{config.provisioning_path}/client.rb -j #{config.provisioning_path}/dna.json"
+
+        env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(command) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, command)
+            else
+              env.ui.info("#{data}: #{type}")
+            end
+          end
+        end
+      end
+
+      def validation_key_path
+        File.expand_path(config.validation_key_path, env.root_path)
+      end
+
+      def encrypted_data_bag_secret_key_path
+        File.expand_path(config.encrypted_data_bag_secret_key_path, env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(config.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -0,0 +1,135 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-solo.
+    class ChefSolo < Chef
+      register :chef_solo
+
+      extend Util::Counter
+      include Util::Counter
+
+      class Config < Chef::Config
+        attr_accessor :cookbooks_path
+        attr_accessor :roles_path
+        attr_accessor :data_bags_path
+        attr_accessor :recipe_url
+        attr_accessor :nfs
+
+        def initialize
+          super
+
+          @cookbooks_path = ["cookbooks", [:vm, "cookbooks"]]
+          @roles_path = nil
+          @data_bags_path = nil
+          @nfs = false
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !run_list || run_list.empty?
+        end
+      end
+
+      attr_reader :cookbook_folders
+      attr_reader :role_folders
+      attr_reader :data_bags_folders
+
+      def prepare
+        @cookbook_folders = expanded_folders(config.cookbooks_path)
+        @role_folders = expanded_folders(config.roles_path)
+        @data_bags_folders = expanded_folders(config.data_bags_path)
+
+        share_folders("csc", @cookbook_folders)
+        share_folders("csr", @role_folders)
+        share_folders("csdb", @data_bags_folders)
+      end
+
+      def provision!
+        verify_binary(chef_binary_path("chef-solo"))
+        chown_provisioning_folder
+        setup_json
+        setup_solo_config
+        run_chef_solo
+      end
+
+      # Converts paths to a list of properly expanded paths with types.
+      def expanded_folders(paths)
+        return [] if paths.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)
+
+        paths.map do |path|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          # Create the local/remote path based on whether this is a host
+          # or VM path.
+          local_path = nil
+          local_path = File.expand_path(path, env.root_path) if type == :host
+          remote_path = nil
+          if type == :host
+            # 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)
+          end
+
+          # Return the result
+          [type, local_path, remote_path]
+        end
+      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(prefix, folders)
+        folders.each do |type, local_path, remote_path|
+          if type == :host
+            env.config.vm.share_folder("v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
+                                       remote_path, local_path, :nfs => config.nfs)
+          end
+        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
+
+        setup_config("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,
+        })
+      end
+
+      def run_chef_solo
+        command_env = config.binary_env ? "#{config.binary_env} " : ""
+        command = "#{command_env}#{chef_binary_path("chef-solo")} -c #{config.provisioning_path}/solo.rb -j #{config.provisioning_path}/dna.json"
+
+        env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(command) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, command)
+            else
+              env.ui.info("#{data}: #{type}")
+            end
+          end
+        end
+      end
+
+      # Extracts only the remote paths from a list of folders
+      def guest_paths(folders)
+        folders.map { |parts| parts[2] }
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/puppet.rb

@@ -0,0 +1,137 @@
+module Vagrant
+  module Provisioners
+    class PuppetError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet")
+    end
+
+    class Puppet < Base
+      register :puppet
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :pp_path
+        attr_accessor :options
+
+        def initialize
+          @manifest_file = nil
+          @manifests_path = "manifests"
+          @module_path = nil
+          @pp_path = "/tmp/vagrant-puppet"
+          @options = []
+        end
+
+        # Returns the manifests path expanded relative to the root path of the
+        # environment.
+        def expanded_manifests_path
+          Pathname.new(manifests_path).expand_path(env.root_path)
+        end
+
+        # Returns the manifest file if set otherwise returns the box name pp file
+        # which may or may not exist.
+        def computed_manifest_file
+          manifest_file || "#{top.vm.box}.pp"
+        end
+
+        # Returns the module paths as an array of paths expanded relative to the
+        # root path.
+        def expanded_module_paths
+          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(env.root_path)
+          end
+        end
+
+        def validate(errors)
+          super
+
+          # Manifests path/file validation
+          if !expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+          else
+            if !expanded_manifests_path.join(computed_manifest_file).file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file))
+            end
+          end
+
+          # Module paths validation
+          expanded_module_paths.each do |path|
+            if !path.directory?
+              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
+            end
+          end
+        end
+      end
+
+      def prepare
+        set_module_paths
+        share_manifests
+        share_module_paths
+      end
+
+      def provision!
+        verify_binary("puppet")
+        run_puppet_client
+      end
+
+      def share_manifests
+        env.config.vm.share_folder("manifests", manifests_guest_path, config.expanded_manifests_path)
+      end
+
+      def share_module_paths
+        count = 0
+        @module_paths.each do |from, to|
+          # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+          # maximum size for it and its something small (around 10)
+          env.config.vm.share_folder("v-pp-m#{count}", to, from)
+          count += 1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = {}
+        config.expanded_module_paths.each_with_index do |path, i|
+          @module_paths[path] = File.join(config.pp_path, "modules-#{i}")
+        end
+      end
+
+      def manifests_guest_path
+        File.join(config.pp_path, "manifests")
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
+        options << config.computed_manifest_file
+        options = options.join(" ")
+
+        commands = ["cd #{manifests_guest_path}",
+                    "puppet apply #{options}"]
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet", :manifest => config.computed_manifest_file)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo! commands do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/puppet_server.rb

@@ -0,0 +1,55 @@
+module Vagrant
+  module Provisioners
+    class PuppetServerError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet_server")
+    end
+
+    class PuppetServer < Base
+      register :puppet_server
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+
+        def initialize
+          @puppet_server = "puppet"
+          @puppet_node = "puppet_node"
+          @options = []
+        end
+      end
+
+      def provision!
+        verify_binary("puppetd")
+        run_puppetd_client
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetServerError, :_key => :puppetd_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppetd_client
+        options = config.options
+        options = options.join(" ") if options.is_a?(Array)
+        if config.puppet_node
+          cn = config.puppet_node
+        else
+          cn = env.config.vm.box
+        end
+
+        commands = "puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |channel, type, data|
+            ssh.check_exit_status(data, commands) if type == :exit_status
+            env.ui.info(data) if type != :exit_status
+          end
+        end
+      end
+    end
+  end
+end