vagrant-berkshelf-nochefdk 6.0.0

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

@@ -0,0 +1,35 @@
+require_relative 'base'
+
+module VagrantPlugins
+  module Berkshelf
+    module Action
+      class Install < 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
+
+          vendor(env)
+          @app.call(env)
+        end
+
+        # Vendor the cookbooks in the Berkshelf shelf.
+        def vendor(env)
+          shelf = env[:berkshelf].shelf
+          env[:machine].ui.info "Updating Vagrant's Berkshelf..."
+
+          options = env[:machine].config.berkshelf.to_hash
+
+          result = berks('vendor', shelf, options)
+          env[:machine].ui.output(result.stdout)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+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 !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
+          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/save.rb

@@ -0,0 +1,27 @@
+require_relative 'base'
+
+module VagrantPlugins
+  module Berkshelf
+    module Action
+      class Save < Base
+        def call(env)
+          if !berkshelf_enabled?(env)
+            @logger.info "Berkshelf disabled, skipping"
+            return @app.call(env)
+          end
+
+          if env[:berkshelf].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
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,33 @@
+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 !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 + Array(chef.config.cookbooks_path)
+          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.nil?
+              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(path), 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_path: env[:machine].config.berkshelf.berksfile_path,
+                  force:          true,
+                  freeze:         false,
+                )
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/config.rb

@@ -0,0 +1,107 @@
+require 'pathname'
+require 'vagrant/util/hash_with_indifferent_access'
+
+module VagrantPlugins
+  module Berkshelf
+    class Config < Vagrant.plugin("2", :config)
+      MAYBE = Object.new.freeze
+
+      # 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
+        @enabled = MAYBE if @enabled == UNSET_VALUE
+
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        if @enabled || @enabled == MAYBE
+          # If no Berksfile path was given, check if one is in the working
+          # directory
+          if !@berksfile_path
+            path = File.expand_path("Berksfile", machine.env.root_path)
+
+            if File.exist?(path)
+              @enabled = true
+              @berksfile_path = path
+            else
+              # Disable the plugin unless it was specifically set to "true". If
+              # the user set the value, we want to return an error, but if the
+              # user did not explicitly enable the plugin, we should just
+              # disable it automatically.
+              @enabled = false unless @enabled == true
+            end
+          end
+
+          if @enabled
+            # Berksfile_path validations
+            if missing?(@berksfile_path)
+              errors << "berksfile_path must be set"
+            else
+              # Expand the path unless it is absolute
+              if !Pathname.new(@berksfile_path).absolute?
+                @berksfile_path = File.expand_path(@berksfile_path, machine.env.root_path)
+              end
+
+              # Ensure the path exists
+              if !File.exist?(@berksfile_path)
+                errors << "Berksfile at '#{@berksfile_path}' does not exist"
+              end
+            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
+
+      def missing?(obj)
+        obj.to_s.strip.empty?
+      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,49 @@
+require 'vagrant/errors'
+
+module VagrantPlugins
+  module Berkshelf
+    class BerkshelfNotFound < Vagrant::Errors::VagrantError
+      def error_message
+        "Vagrant Berkshelf could not find the 'berks' executable in your PATH."
+      end
+    end
+
+    class BerksCommandFailed < Vagrant::Errors::VagrantError
+      def initialize(command, stdout, stderr)
+        @command, @stdout, @stderr = command, stdout, stderr
+        super
+      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
+      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}.
+EOH
+      end
+    end
+  end
+end

data/lib/vagrant-berkshelf/helpers.rb

@@ -0,0 +1,150 @@
+require 'json'
+require 'open3'
+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[:freeze] == false
+          args << "--no-freeze"
+        end
+
+        if options[:force]
+          args << "--force"
+        end
+
+        if !options.fetch(:args, []).empty?
+          args += options[:args]
+        end
+
+        final_command = [berks_bin, command, *args]
+
+        sanitized_env = ENV.to_h.merge('GEM_HOME' => nil, 'GEM_PATH' => nil)
+        command = final_command.join(' ')
+        out, err, status = Open3.capture3(sanitized_env, command)
+        raise BerksCommandFailed.new(command, out, err) unless status.success?
+        OpenStruct.new(stdout: out, stderr: err)
+      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 == true
+      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
+
+    end
+  end
+end