vagrant-berkshelf 3.0.1 → 4.0.0

data/lib/berkshelf/vagrant/chef_config.rb

@@ -1,88 +0,0 @@
-require 'vagrant/util/hash_with_indifferent_access'
-require 'pathname'
-
-module Berkshelf::Vagrant
-  class ChefConfig < ::Vagrant::Util::HashWithIndifferentAccess
-    class << self
-      # Return the most sensible path to the Chef configuration file. This can
-      # be configured by setting a value for the 'CHEF_CONFIG' environment
-      # variable.
-      #
-      # @return [String, nil]
-      def location
-        possibles = []
-
-        possibles << ENV['CHEF_CONFIG'] if ENV['CHEF_CONFIG']
-        possibles << File.join(ENV['KNIFE_HOME'], 'knife.rb') if ENV['KNIFE_HOME']
-        possibles << File.join(Dir.pwd, 'knife.rb')
-
-        # Ascending search for .chef directory siblings
-        Pathname.new(Dir.pwd).ascend do |file|
-          sibling_chef = File.join(file, '.chef')
-          possibles << File.join(sibling_chef, 'knife.rb')
-        end
-
-        possibles << File.join(ENV['HOME'], '.chef', 'knife.rb') if ENV['HOME']
-        possibles.compact!
-
-        location = possibles.find { |loc| File.exists?(File.expand_path(loc)) }
-
-        File.expand_path(location) unless location.nil?
-      end
-
-      def instance
-        @instance ||= from_file(location)
-      end
-
-      def from_file(file = nil)
-        file = file.nil? ? location : file
-        if !file.nil? && File.exist?(file) && File.readable?(file)
-          contents = File.read(file)
-          return parse(contents, file)
-        end
-
-        new
-      end
-
-      def parse(contents, path = nil)
-        new(contents, path)
-      end
-    end
-
-    def initialize(contents = "", path = "")
-      instance_eval(contents, path)
-    end
-
-    def chef_server_url(value = nil)
-      set_or_return(:chef_server_url, value)
-    end
-
-    def client_key(value = nil)
-      set_or_return(:client_key, value)
-    end
-
-    def node_name(value = nil)
-      set_or_return(:node_name, value)
-    end
-
-    def method_missing(m, *args, &block)
-      Proxy.new
-    end
-
-    private
-
-      def set_or_return(key, value)
-        if value.nil?
-          return self[key]
-        else
-          self[key] = value
-        end
-      end
-
-      class Proxy
-        def method_missing(m, *args, &block)
-          self
-        end
-      end
-  end
-end

data/lib/berkshelf/vagrant/config.rb

@@ -1,113 +0,0 @@
-require 'vagrant/util/hash_with_indifferent_access'
-
-module Berkshelf
-  module Vagrant
-    class Config < ::Vagrant.plugin("2", :config)
-      # @return [String]
-      #   path to the Berksfile to use with Vagrant
-      attr_reader :berksfile_path
-
-      # @return [Boolean]
-      #   disable of use Berks in Vagrant
-      attr_accessor :enabled
-
-      # @return [Array<Symbol>]
-      #   only cookbooks in these groups will be installed and copied to
-      #   Vagrant's shelf
-      attr_accessor :only
-
-      # @return [Array<Symbol>]
-      #   cookbooks in all other groups except for these will be installed
-      #   and copied to Vagrant's shelf
-      attr_accessor :except
-
-      # @return [String]
-      #   the Chef node name (client name) to use to authenticate with the remote
-      #   chef server to upload cookbooks when using the chef client provisioner
-      attr_accessor :node_name
-
-      # @return [String]
-      #   a filepath to a chef client key to use to authenticate with the remote
-      #   chef server to upload cookbooks when using the chef client provisioner
-      attr_accessor :client_key
-
-      def initialize
-        super
-
-        @berksfile_path = UNSET_VALUE
-        @except         = Array.new
-        @only           = Array.new
-        @node_name      = BerksConfig.instance.chef[:node_name]
-        @client_key     = BerksConfig.instance.chef[:client_key]
-        @enabled        = UNSET_VALUE
-      end
-
-      def finalize!
-        @berksfile_path = File.join(Dir.pwd, "Berksfile") if @berksfile_path == UNSET_VALUE
-        @enabled        = File.exist?(@berksfile_path) if @enabled == UNSET_VALUE
-      end
-
-      # @param [String] value
-      def berksfile_path=(value)
-        @berksfile_path = value
-      end
-
-      # @param [String] value
-      def client_key=(value)
-        @client_key = value
-      end
-
-      def to_hash
-        ::Vagrant::Util::HashWithIndifferentAccess.new(instance_variables_hash)
-      end
-
-      def validate(machine)
-        errors = Array.new
-        unless @berksfile_path.nil?
-          @berksfile_path = File.expand_path(@berksfile_path, machine.env.root_path.to_s)
-        end
-        unless @client_key.nil?
-          @client_key = File.expand_path(@client_key, machine.env.root_path.to_s)
-        end
-
-        unless [TrueClass, FalseClass].include?(enabled.class)
-          errors << "A value for berkshelf.enabled can be true or false."
-        end
-
-        if enabled
-          if machine.config.berkshelf.berksfile_path.nil?
-            errors << "berkshelf.berksfile_path cannot be nil."
-          end
-
-          unless File.exist?(machine.config.berkshelf.berksfile_path)
-            errors << "No Berksfile was found at #{machine.config.berkshelf.berksfile_path}."
-          end
-
-          if !except.empty? && !only.empty?
-            errors << "A value for berkshelf.empty and berkshelf.only cannot both be defined."
-          end
-
-          if global_provisioners(machine).any? { |prov| prov.name == :chef_client }
-            if machine.config.berkshelf.node_name.nil?
-              errors << "A configuration must be set node_name when using the chef_client provisioner." +
-                        " Edit your berkshelf configuration and add a value for chef.node_name."
-            end
-
-            if machine.config.berkshelf.client_key.nil?
-              errors << "A configuration must be set for client_key when using the chef_client provisioner." +
-                        " Edit your berkshelf configuration and add a value for chef.client_key."
-            end
-          end
-        end
-
-        {"berkshelf configuration" => errors}
-      end
-
-      private
-
-        def global_provisioners(machine)
-          machine.env.vagrantfile.config.vm.provisioners
-        end
-    end
-  end
-end

data/lib/berkshelf/vagrant/env.rb

@@ -1,16 +0,0 @@
-module Berkshelf
-  module Vagrant
-    # Environment data to build up and persist through the middleware chain
-    class Env
-      # @return [Vagrant::UI::Colored]
-      attr_accessor :ui
-      # @return [String]
-      attr_accessor :shelf
-
-      def initialize
-        @ui               = ::Vagrant::UI::Colored.new
-        @ui.opts[:target] = 'Berkshelf'
-      end
-    end
-  end
-end

data/lib/berkshelf/vagrant/env_helpers.rb

@@ -1,160 +0,0 @@
-require 'buff/shell_out'
-require 'json'
-require 'vagrant/util/which'
-
-module Berkshelf
-  module Vagrant
-    # A module of common helper functions that can be mixed into Berkshelf::Vagrant actions
-    module EnvHelpers
-      BERKS_CONSTRAINT = ">= 3.0.0"
-
-      include Buff::ShellOut
-      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 [UnsupportedBerksVersion]
-      #   version of Berks installed does not satisfy the application's constraint
-      # @raise [BerksNotFound]
-      #   berks command is not found in the user's path
-      # @raise [BerksError]
-      #   CLI command failed
-      def berks(command, *args)
-        if defined?(Bundler)
-          Bundler.with_clean_env { run_berks(command, *args) }
-        else
-          run_berks(command, *args)
-        end
-      end
-
-      def berksfile_path(env)
-        env[:machine].env.vagrantfile.config.berkshelf.berksfile_path
-      end
-
-      # A file to persist vagrant-berkshelf specific information in between
-      # Vagrant runs.
-      #
-      # @return [String]
-      def cache_file(env)
-        File.expand_path(File.join('.vagrant', 'machines', env[:machine].name.to_s, 'berkshelf'), env[:root_path].to_s)
-      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(name, env)
-        env[:machine].config.vm.provisioners.select { |prov| prov.name == name }
-      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_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_disabled?(env)
-        env.has_key?(:provision_enabled) && !env[:provision_enabled]
-      end
-
-      private
-
-        def berks_version_check!
-          if (exec = Which.which("berks")).nil?
-            raise BerksNotFound
-          end
-
-          unless (response = shell_out("#{exec} version -F json")).success?
-            raise "Couldn't determine Berks version: #{response.inspect}"
-          end
-
-          begin
-            version = Gem::Version.new(JSON.parse(response.stdout)["version"])
-            Gem::Requirement.new(BERKS_CONSTRAINT).satisfied_by?(version)
-            exec
-          rescue => ex
-            raise UnsupportedBerksVersion.new(exec, BERKS_CONSTRAINT, version)
-          end
-        end
-
-        def options_to_flags(opts)
-          opts.map do |key, value|
-            if value.is_a?(TrueClass)
-              "--#{key_to_flag(key)}"
-              next
-            end
-
-            if value.is_a?(FalseClass)
-              "--no-#{key_to_flag(key)}"
-              next
-            end
-
-            if value.is_a?(Array)
-              "--#{key_to_flag(key)}=#{value.join(" ")}"
-              next
-            end
-
-            "--#{key_to_flag(key)}=#{value}"
-          end.join(" ")
-        end
-
-        def run_berks(command, *args)
-          exec      = berks_version_check!
-          options   = args.last.is_a?(Hash) ? args.pop : Hash.new
-          arguments = args.join(" ")
-          flags     = options_to_flags(options)
-
-          command = "#{exec} #{command} #{arguments} #{flags}"
-          unless (response = shell_out(command)).success?
-            raise BerksError.new("Berks command Failed: #{command}, reason: #{response.stderr}")
-          end
-          response.stdout
-        end
-
-        def key_to_flag(key)
-          "#{key.to_s.gsub("_", "-")}"
-        end
-    end
-  end
-end

data/lib/berkshelf/vagrant/errors.rb

@@ -1,71 +0,0 @@
-require 'vagrant/errors'
-
-module Berkshelf
-  # A wrapper for a BerkshelfError for Vagrant. All Berkshelf exceptions should be
-  # wrapped in this proxy object so they are properly handled when Vagrant encounters
-  # an exception.
-  #
-  # @example wrapping an error encountered within the Vagrant plugin
-  #   rescue BerkshelfError => e
-  #     VagrantWrapperError.new(e)
-  #   end
-  class VagrantWrapperError < ::Vagrant::Errors::VagrantError
-    # @param [BerkshelfError]
-    attr_reader :original
-
-    # @param [BerkshelfError] original
-    def initialize(original)
-      @original = original
-    end
-
-    def to_s
-      "#{original.class}: #{original.to_s}"
-    end
-
-    private
-
-      def method_missing(fun, *args, &block)
-        original.send(fun, *args, &block)
-      end
-  end
-
-  class BerksError < ::Vagrant::Errors::VagrantError
-    attr_reader :error_message
-
-    def initialize(message)
-      @error_message = message
-      super
-    end
-  end
-
-  class BerksNotFound < ::Vagrant::Errors::VagrantError
-    def error_message
-      "Berks not found. Download the ChefDK from http://downloads.getchef.com/chef-dk and add it to your $PATH."
-    end
-  end
-
-  class UnsupportedBerksVersion < ::Vagrant::Errors::VagrantError
-    def initialize(bin, constraint, version)
-      @bin        = bin
-      @constraint = constraint
-      @version    = version
-      super
-    end
-
-    def error_message
-      "Unsupported Berkshelf version at: #{@bin}. Requires #{@constraint} and got #{@version}." +
-      " Download the latest version of the ChefDK from http://downloads.getchef.com/chef-dk and add it to your $PATH."
-    end
-  end
-
-  class UnsupportedVagrantVersion < ::Vagrant::Errors::VagrantError
-    def initialize(constraint)
-      @constraint = constraint
-      super
-    end
-
-    def error_message
-      "vagrant-berkshelf requires Vagrant #{@constraint}."
-    end
-  end
-end