vagrant-berkshelf 3.0.1 → 4.0.0

data/lib/vagrant-berkshelf/action/load.rb

@@ -0,0 +1,59 @@
+require_relative 'base'
+
+module VagrantPlugins
+  module Berkshelf
+    module Action
+      class Load < Base
+        def call(env)
+          if !berkshelf_enabled?(env)
+            @logger.info "Berkshelf disabled, skipping"
+            return @app.call(env)
+          end
+
+          if File.exist?(datafile_path(env))
+            env[:machine].ui.info "Loading Berkshelf datafile..."
+            shelf = File.read(datafile_path(env)).chomp
+
+            @logger.debug "Shelf: #{shelf.inspect}"
+
+            env[:berkshelf].shelf = shelf
+          end
+
+          if !provision_enabled?(env)
+            @logger.info "Provisioning disabled, skipping"
+            return @app.call(env)
+          end
+
+          if !env[:berkshelf].shelf
+            shelf = mkshelf(env)
+            env[:machine].ui.detail "The Berkshelf shelf is at #{shelf.inspect}"
+
+            @logger.debug "Persisting datafile share to memory"
+            env[:berkshelf].shelf = shelf
+
+            @logger.debug "Saving datafile to disk"
+            FileUtils.mkdir_p(datafile_path(env).dirname)
+            datafile_path(env).open("w+") do |f|
+              f.write(env[:berkshelf].shelf)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        # Create a new Berkshelf shelf for the current machine.
+        # @return [String]
+        #   the path to the temporary directory
+        def mkshelf(env)
+          shelves = Berkshelf.shelves_path
+
+          if !File.exist?(shelves)
+            FileUtils.mkdir_p(shelves)
+          end
+
+          Dir.mktmpdir(['berkshelf', "-#{env[:machine].name}"], shelves)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/action/share.rb

@@ -0,0 +1,38 @@
+require_relative 'base'
+
+module VagrantPlugins
+  module Berkshelf
+    module Action
+      class Share < Base
+        def call(env)
+          if !berkshelf_enabled?(env)
+            @logger.info "Berkshelf disabled, skipping"
+            return @app.call(env)
+          end
+
+          if !provision_enabled?(env)
+            @logger.info "Provisioning disabled, skipping"
+            return @app.call(env)
+          end
+
+          if !chef_solo?(env) && !chef_zero?(env)
+            @logger.info "Provisioner does not need a share"
+            return @app.call(env)
+          end
+
+          env[:machine].ui.info "Sharing cookbooks with VM"
+
+          list = provisioners(:chef_solo, env) + provisioners(:chef_zero, env)
+          list.each do |chef|
+            value = chef.config.send(:prepare_folders_config, env[:berkshelf].shelf)
+
+            @logger.debug "Setting cookbooks_path = #{value.inspect}"
+            chef.config.cookbooks_path = value
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/action/upload.rb

@@ -0,0 +1,99 @@
+require 'json'
+require 'tempfile'
+
+require_relative 'base'
+
+module VagrantPlugins
+  module Berkshelf
+    module Action
+      class Upload < Base
+        def call(env)
+          if !berkshelf_enabled?(env)
+            @logger.info "Berkshelf disabled, skipping"
+            return @app.call(env)
+          end
+
+          if !provision_enabled?(env)
+            @logger.info "Provisioning disabled, skipping"
+            return @app.call(env)
+          end
+
+          if !chef_client?(env)
+            @logger.info "Provisioner does need to upload"
+            return @app.call(env)
+          end
+
+          upload(env)
+          @app.call(env)
+        end
+
+        private
+
+          # Generate a custom Berkshelf config from the existing Berkshelf
+          # config on disk, with values in the Vagrantfile taking precedence,
+          # based on the current provisioner. It is assumed the provisioner is
+          # the "chef_client" provisioner.
+          #
+          # The path to the temporary configuration file is yielded to the
+          # block. This method ensures the temporary file is cleaned up
+          # automatically.
+          #
+          # @param [Vagrant::Provisioner] provisioner
+          # @param [Proc] block
+          def with_provision_berkshelf_config(provisioner, &block)
+            config = current_berkshelf_config
+
+            config[:chef] ||= {}
+            config[:chef].merge(
+              chef_server_url:        provisioner.config.chef_server_url,
+              node_name:              provisioner.config.node_name,
+              client_key:             provisioner.config.client_key_path,
+              validation_key:         provisioner.config.validation_key_path,
+              validation_client_name: provisioner.config.validation_client_name,
+            )
+
+            tmpfile = Tempfile.new('config.json')
+            tmpfile.write(config.to_json)
+            tmpfile.rewind
+            yield tmpfile.path
+          ensure
+            if defined?(tmpfile)
+              tmpfile.close
+              tmpfile.unlink
+            end
+          end
+
+          # The current JSON representation of the Berkshelf config on disk.
+          #
+          # @return [Hash<Symbol, Object>]
+          def current_berkshelf_config
+            path = File.expand_path(ENV['BERKSHELF_CONFIG'] || '~/.berkshelf/config.json')
+
+            if File.exist?(path)
+              JSON.parse(File.read(), symbolize_names: true)
+            else
+              {}
+            end
+          end
+
+          # Upload the resolved Berkshelf cookbooks to the target Chef Server
+          # specified in the Vagrantfile.
+          #
+          # @param [Vagrant::Environment] env
+          def upload(env)
+            provisioners(:chef_client, env).each do |provisioner|
+              with_provision_berkshelf_config(provisioner) do |config|
+                env[:machine].ui.info "Uploading cookbooks to #{provisioner.config.chef_server_url}"
+                berks("upload",
+                  config:    config,
+                  berksfile: provisioner.config.berkshelf.berksfile_path,
+                  force:     true,
+                  freeze:    false,
+                )
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/config.rb

@@ -0,0 +1,87 @@
+require 'pathname'
+require 'vagrant/util/hash_with_indifferent_access'
+
+module VagrantPlugins
+  module Berkshelf
+    class Config < Vagrant.plugin("2", :config)
+      # The path to the Berksfile to use.
+      # @return [String]
+      attr_accessor :berksfile_path
+
+      # Disable the use of Berkshelf in Vagrant.
+      # @return [Boolean]
+      attr_accessor :enabled
+
+      # The array of cookbook groups to exclusively install during provisioning.
+      # @return [Array<Symbol>]
+      attr_accessor :only
+
+      # The array of cookbook groups to exclude during provisioning.
+      # @return [Array<Symbol>]
+      attr_accessor :except
+
+      # An array of additional arguments to pass to the Berkshelf command.
+      # @return [Array<String>]
+      attr_accessor :args
+
+      def initialize
+        super
+
+        @berksfile_path = UNSET_VALUE
+        @enabled        = UNSET_VALUE
+        @except         = Array.new
+        @only           = Array.new
+        @args           = Array.new
+
+        @__finalized = false
+      end
+
+      def finalize!
+        @berksfile_path = nil if @berksfile_path == UNSET_VALUE
+
+        if @enabled == UNSET_VALUE
+          if @berksfile_path
+            # Automatically enable if a Berksfile path was given
+            @enabled = true
+          elsif File.exist?("Berksfile")
+            # Automatically enable when a Berksfile is persent
+            @berksfile_path = "Berksfile"
+            @enabled = true
+          end
+        end
+
+        @enabled = false if @enabled == UNSET_VALUE
+
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        if @enabled
+          if @berksfile_path.to_s.strip.empty?
+            errors << "berksfile_path must be set"
+          else
+            unless Pathname.new(@berksfile_path).absolute?
+              @berksfile_path = File.expand_path(@berksfile_path, machine.env.root_path)
+            end
+          end
+        end
+
+        { "Berkshelf" => errors }
+      end
+
+      def to_hash
+        raise "Must finalize first." if !@__finalized
+
+        {
+          enabled:        @enabled,
+          berksfile_path: @berksfile_path,
+          except:         @except,
+          only:           @only,
+          args:           @args,
+        }
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/env.rb

@@ -0,0 +1,14 @@
+require 'vagrant/ui'
+
+module VagrantPlugins
+  module Berkshelf
+    class Env
+      # @return [String]
+      attr_accessor :shelf
+
+      def initialize
+        @shelf = nil
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/errors.rb

@@ -0,0 +1,79 @@
+require 'vagrant/errors'
+
+module VagrantPlugins
+  module Berkshelf
+    INSTALL_CHEFDK_INSTRUCTIONS = <<-EOH.freeze
+Please download and install the latest version of the ChefDK from:
+
+    https://downloads.getchef.com/chef-dk
+
+and follow the installation instructions. Do not forget to add the ChefDK to
+your PATH.
+EOH
+
+    class BerkshelfNotFound < Vagrant::Errors::VagrantError
+      def error_message
+        <<-EOH
+Vagrant Berkshelf could not find the 'berks' executable in your PATH.
+
+#{INSTALL_CHEFDK_INSTRUCTIONS}
+EOH
+      end
+    end
+
+    class BerksCommandFailed < Vagrant::Errors::VagrantError
+      def initialize(command, stdout, stderr)
+        @command, @stdout, @stderr = command, stdout, stderr
+        super
+      end
+
+      def chefdk?
+        @command.include?("chefdk")
+      end
+
+      def not_chefdk_message
+        <<-EOH
+It appears that you are not using the ChefDK. Please note that Vagrant Berkshelf
+works best when used with the ChefDK, and other installation methods are not
+officially supported.
+
+#{INSTALL_CHEFDK_INSTRUCTIONS}
+EOH
+      end
+
+      def error_message
+        base = <<-EOH
+The following berks command failed to execute:
+
+    #{@command}
+
+The stdout and stderr are shown below:
+
+    stdout: #{@stdout}
+    stderr: #{@stderr}
+EOH
+
+        base << "\n#{not_chefdk_message}" if !chefdk?
+        base
+      end
+    end
+
+    class InvalidBerkshelfVersionError < Vagrant::Errors::VagrantError
+      def initialize(bin, constraint, version)
+        @bin        = bin
+        @constraint = constraint
+        @version    = version
+        super
+      end
+
+      def error_message
+        <<-EOH
+The Berkshelf version at #{@bin.inspect} is invalid.
+Vagrant Berkshelf requires #{@constraint}, but the current version is #{@version}.
+
+#{INSTALL_CHEFDK_INSTRUCTIONS}
+EOH
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/helpers.rb

@@ -0,0 +1,180 @@
+require 'json'
+require 'vagrant/util'
+
+require_relative 'errors'
+
+module VagrantPlugins
+  module Berkshelf
+    # A module of common helper functions that can be mixed into Berkshelf::Vagrant actions
+    module Helpers
+      include Vagrant::Util
+
+      # Execute a berkshelf command with the given arguments and flags.
+      #
+      # @overload berks(command, args)
+      #   @param [String] berks CLI command to run
+      #   @param [Object] any number of arguments to pass to CLI
+      # @overload berks(command, args, options)
+      #   @param [String] berks CLI command to run
+      #   @param [Object] any number of arguments to pass to CLI
+      #   @param [Hash] options to convert to flags for the CLI
+      #
+      # @return [String]
+      #   output of the command
+      #
+      # @raise [InvalidBerkshelfVersionError]
+      #   version of Berks installed does not satisfy the application's constraint
+      # @raise [BerksNotFoundError]
+      #   berks command is not found in the user's path
+      def berks(command, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args = args.dup
+
+        if options[:berksfile_path]
+          args << "--berksfile"
+          args << options[:berksfile_path]
+        end
+
+        if !options.fetch(:except, []).empty?
+          args << "--except"
+          args += options[:except]
+        end
+
+        if !options.fetch(:only, []).empty?
+          args << "--only"
+          args += options[:only]
+        end
+
+        if !options.fetch(:args, []).empty?
+          args += options[:args]
+        end
+
+        final_command = [berks_bin, command, *args]
+
+        Bundler.with_clean_env do
+          r = Subprocess.execute(*final_command)
+          if r.exit_code != 0
+            raise BerksCommandFailed.new(final_command.join(' '), r.stdout, r.stderr)
+          end
+          r
+        end
+      end
+
+      # The path to the Berkshelf binary on disk.
+      # @return [String, nil]
+      def berks_bin
+        Which.which("berks")
+      end
+
+      # Filter all of the provisioners of the given vagrant environment with the given name
+      #
+      # @param [Symbol] name
+      #   name of provisioner to filter
+      # @param [Vagrant::Environment, Hash] env
+      #   environment to inspect
+      #
+      # @return [Array]
+      def provisioners(type, env)
+        env[:machine].config.vm.provisioners.select do |provisioner|
+          # Vagrant 1.7 changes provisioner.name to provisioner.type
+          if provisioner.respond_to? :type
+            provisioner.type.to_sym == type
+          else
+            provisioner.name.to_sym == type
+          end
+        end
+      end
+
+      # Determine if the given vagrant environment contains a chef_solo provisioner
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [Boolean]
+      def chef_solo?(env)
+        provisioners(:chef_solo, env).any?
+      end
+
+      # Determine if the given vagrant environment contains a chef_zero provisioner
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [Boolean]
+      def chef_zero?(env)
+        provisioners(:chef_zero, env).any?
+      end
+
+      # Determine if the given vagrant environment contains a chef_client provisioner
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [Boolean]
+      def chef_client?(env)
+        provisioners(:chef_client, env).any?
+      end
+
+      # Determine if the Berkshelf plugin should be run for the given environment
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [Boolean]
+      def berkshelf_enabled?(env)
+        env[:machine].config.berkshelf.enabled
+      end
+
+      # Determine if --no-provision was specified
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [Boolean]
+      def provision_enabled?(env)
+        env.fetch(:provision_enabled, true)
+      end
+
+      # The path to the Vagrant Berkshelf data file inside the machine's data
+      # directory.
+      #
+      # @return [String]
+      def datafile_path(env)
+        env[:machine].data_dir.join("berkshelf")
+      end
+
+      #
+      # Execute the given command, removing any Ruby-specific environment
+      # variables. This is an "enhanced" version of +Bundler.with_clean_env+,
+      # which only removes Bundler-specific values. We need to remove all
+      # values, specifically:
+      #
+      # - _ORIGINAL_GEM_PATH
+      # - GEM_PATH
+      # - GEM_HOME
+      # - GEM_ROOT
+      # - BUNDLE_BIN_PATH
+      # - BUNDLE_GEMFILE
+      # - RUBYLIB
+      # - RUBYOPT
+      # - RUBY_ENGINE
+      # - RUBY_ROOT
+      # - RUBY_VERSION
+      #
+      # This will escape Vagrant's environment entirely, which is required if
+      # calling an executable that lives in another Ruby environment. The
+      # original environment restored at the end of this call.
+      #
+      # @param [Proc] block
+      #   the block to execute with the cleaned environment
+      #
+      def with_clean_env(&block)
+        original = ENV.to_hash
+
+        ENV.delete("_ORIGINAL_GEM_PATH")
+        ENV.delete_if { |k,_| k.start_with?("BUNDLE_") }
+        ENV.delete_if { |k,_| k.start_with?("GEM_") }
+        ENV.delete_if { |k,_| k.start_with?("RUBY") }
+
+        yield
+      ensure
+        ENV.replace(original.to_hash)
+      end
+    end
+  end
+end