berkshelf 5.2.0 → 8.0.15

data/lib/berkshelf/commands/shelf.rb

@@ -1,7 +1,7 @@
 module Berkshelf
   # All tasks that operate on the Berkshelf shelf.
   class Shelf < Thor
-    desc 'list', 'List all cookbooks and their versions'
+    desc "list", "List all cookbooks and their versions"
     def list
       cookbooks = store.cookbooks.inject({}) do |hash, cookbook|
         (hash[cookbook.cookbook_name] ||= []).push(cookbook.version)
@@ -9,17 +9,17 @@ module Berkshelf
       end
 
       if cookbooks.empty?
-        Berkshelf.formatter.msg 'There are no cookbooks in the Berkshelf shelf'
+        Berkshelf.formatter.msg "There are no cookbooks in the Berkshelf shelf"
       else
-        Berkshelf.formatter.msg 'Cookbooks in the Berkshelf shelf:'
+        Berkshelf.formatter.msg "Cookbooks in the Berkshelf shelf:"
         cookbooks.sort.each do |cookbook, versions|
-          Berkshelf.formatter.msg("  * #{cookbook} (#{versions.sort.join(', ')})")
+          Berkshelf.formatter.msg("  * #{cookbook} (#{versions.sort.join(", ")})")
         end
       end
     end
 
-    method_option :version, aliases: '-v', type: :string, desc: 'Version to show'
-    desc 'show', 'Display information about a cookbook in the Berkshelf shelf'
+    method_option :version, aliases: "-v", type: :string, desc: "Version to show"
+    desc "show", "Display information about a cookbook in the Berkshelf shelf"
     def show(name)
       cookbooks = find(name, options[:version])
 
@@ -35,9 +35,9 @@ module Berkshelf
       end
     end
 
-    method_option :version, aliases: '-v', type: :string,  desc: 'Version to remove'
-    method_option :force,   aliases: '-f', type: :boolean, desc: 'Force removal, even if other cookbooks are contingent', default: false
-    desc 'uninstall', 'Remove a cookbook from the Berkshelf shelf'
+    method_option :version, aliases: "-v", type: :string,  desc: "Version to remove"
+    method_option :force,   aliases: "-f", type: :boolean, desc: "Force removal, even if other cookbooks are contingent", default: false
+    desc "uninstall", "Remove a cookbook from the Berkshelf shelf"
     def uninstall(name)
       cookbooks = find(name, options[:version])
       cookbooks.each { |c| uninstall_cookbook(c, options[:force]) }
@@ -67,14 +67,15 @@ module Berkshelf
       #   the list of cookbooks that match the parameters - this is always an
       #   array!
       def find(name, version = nil)
-        cookbooks = if version
-          [store.cookbook(name, version)].compact
-        else
-          store.cookbooks(name).sort
-        end
+        cookbooks =
+          if version
+            [store.cookbook(name, version)].compact
+          else
+            store.cookbooks(name).sort
+          end
 
         if cookbooks.empty?
-          raise CookbookNotFound.new(name, version, 'in the Berkshelf shelf')
+          raise CookbookNotFound.new(name, version, "in the Berkshelf shelf")
         end
 
         cookbooks
@@ -95,10 +96,10 @@ module Berkshelf
       #   if contingencies exist
       def uninstall_cookbook(cookbook, force = false)
         unless options[:force] || (contingent = contingencies(cookbook)).empty?
-          contingent = contingent.map { |c| "#{c.cookbook_name} (#{c.version})" }.join(', ')
+          contingent = contingent.map { |c| "#{c.cookbook_name} (#{c.version})" }.join(", ")
           confirm = Berkshelf.ui.ask("[#{contingent}] depend on #{cookbook.cookbook_name}.\n\nAre you sure you want to continue? (y/N)")
 
-          exit unless confirm.to_s.upcase[0] == 'Y'
+          exit unless confirm.to_s.upcase[0] == "Y"
         end
 
         FileUtils.rm_rf(cookbook.path)
@@ -120,7 +121,7 @@ module Berkshelf
   end
 
   class Cli < Thor
-    desc 'shelf SUBCOMMAND', 'Interact with the cookbook store'
-    subcommand 'shelf', Berkshelf::Shelf
+    desc "shelf SUBCOMMAND", "Interact with the cookbook store"
+    subcommand "shelf", Berkshelf::Shelf
   end
 end

data/lib/berkshelf/community_rest.rb

@@ -1,9 +1,8 @@
-require 'open-uri'
-require 'retryable'
-require 'mixlib/archive'
+require "retryable" unless defined?(Retryable)
+require "mixlib/archive" unless defined?(Mixlib::Archive)
 
 module Berkshelf
-  class CommunityREST < Faraday::Connection
+  class CommunityREST
     class << self
       # @param [String] target
       #   file path to the tar.gz archive on disk
@@ -25,30 +24,30 @@ module Berkshelf
       #
       # @return [String]
       def uri_escape_version(version)
-        version.to_s.gsub('.', '_')
+        version.to_s.tr(".", "_")
       end
 
       # @param [String] uri
       #
       # @return [String]
       def version_from_uri(uri)
-        File.basename(uri.to_s).gsub('_', '.')
+        File.basename(uri.to_s).tr("_", ".")
       end
 
       private
 
-        def is_gzip_file(path)
-          # You cannot write "\x1F\x8B" because the default encoding of
-          # ruby >= 1.9.3 is UTF-8 and 8B is an invalid in UTF-8.
-          IO.binread(path, 2) == [0x1F, 0x8B].pack("C*")
-        end
+      def is_gzip_file(path)
+        # You cannot write "\x1F\x8B" because the default encoding of
+        # ruby >= 1.9.3 is UTF-8 and 8B is an invalid in UTF-8.
+        IO.binread(path, 2) == [0x1F, 0x8B].pack("C*")
+      end
 
-        def is_tar_file(path)
-          IO.binread(path, 8, 257).to_s == "ustar\x0000"
-        end
+      def is_tar_file(path)
+        IO.binread(path, 8, 257).to_s == "ustar\x0000"
+      end
     end
 
-    V1_API = 'https://supermarket.chef.io'.freeze
+    V1_API = "https://supermarket.chef.io".freeze
 
     # @return [String]
     attr_reader :api_uri
@@ -58,6 +57,8 @@ module Berkshelf
     # @return [Float]
     #   time to wait between retries
     attr_reader :retry_interval
+    # @return [Berkshelf::RidleyCompat]
+    attr_reader :connection
 
     # @param [String] uri (CommunityREST::V1_API)
     #   location of community site to connect to
@@ -67,23 +68,14 @@ module Berkshelf
     # @option options [Float] :retry_interval (0.5)
     #   how often we should pause between retries
     def initialize(uri = V1_API, options = {})
-      options         = options.reverse_merge(retries: 5, retry_interval: 0.5, ssl: Berkshelf::Config.instance.ssl)
-      @api_uri        = uri
-      @retries        = options.delete(:retries)
+      options = options.dup
+      options = { retries: 5, retry_interval: 0.5, ssl: Berkshelf::Config.instance.ssl }.merge(options)
+      @api_uri = uri
+      options[:server_url] = uri
+      @retries = options.delete(:retries)
       @retry_interval = options.delete(:retry_interval)
 
-      options[:builder] ||= Faraday::RackBuilder.new do |b|
-        b.response :parse_json
-        b.response :follow_redirects
-        b.request :retry,
-          max: @retries,
-          interval: @retry_interval,
-          exceptions: [Faraday::Error::TimeoutError]
-
-        b.adapter :httpclient
-      end
-
-      super(api_uri, options)
+      @connection = Berkshelf::RidleyCompatJSON.new(**options)
     end
 
     # Download and extract target cookbook archive to the local file system,
@@ -97,14 +89,14 @@ module Berkshelf
     # @return [String, nil]
     #   cookbook filepath, or nil if archive does not contain a cookbook
     def download(name, version)
-      archive   = stream(find(name, version)[:file])
+      archive = stream(find(name, version)["file"])
       scratch = Dir.mktmpdir
       extracted = self.class.unpack(archive.path, scratch)
 
       if File.cookbook?(extracted)
         extracted
       else
-        Dir.glob(File.join(extracted, '*')).find do |dir|
+        Dir.glob("#{extracted}/*").find do |dir|
           File.cookbook?(dir)
         end
       end
@@ -113,50 +105,53 @@ module Berkshelf
     end
 
     def find(name, version)
-      response = get("cookbooks/#{name}/versions/#{self.class.uri_escape_version(version)}")
-
-      case response.status
-      when (200..299)
-        response.body
-      when 404
-        raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
-      else
-        raise CommunitySiteError.new(api_uri, "'#{name}' (#{version})")
-      end
+      body = connection.get("cookbooks/#{name}/versions/#{self.class.uri_escape_version(version)}")
+
+      # Artifactory responds with a 200 and blank body for unknown cookbooks.
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'") if body.nil?
+
+      body
+    rescue CookbookNotFound
+      raise
+    rescue Berkshelf::APIClient::ServiceNotFound
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
+    rescue
+      raise CommunitySiteError.new(api_uri, "'#{name}' (#{version})")
     end
 
     # Returns the latest version of the cookbook and its download link.
     #
     # @return [String]
     def latest_version(name)
-      response = get("cookbooks/#{name}")
+      body = connection.get("cookbooks/#{name}")
 
-      case response.status
-      when (200..299)
-        self.class.version_from_uri response.body['latest_version']
-      when 404
-        raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
-      else
-        raise CommunitySiteError.new(api_uri, "the latest version of '#{name}'")
-      end
+      # Artifactory responds with a 200 and blank body for unknown cookbooks.
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'") if body.nil?
+
+      self.class.version_from_uri body["latest_version"]
+    rescue Berkshelf::APIClient::ServiceNotFound
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
+    rescue
+      raise CommunitySiteError.new(api_uri, "the latest version of '#{name}'")
     end
 
     # @param [String] name
     #
     # @return [Array]
     def versions(name)
-      response = get("cookbooks/#{name}")
+      body = connection.get("cookbooks/#{name}")
 
-      case response.status
-      when (200..299)
-        response.body['versions'].collect do |version_uri|
-          self.class.version_from_uri(version_uri)
-        end
-      when 404
-        raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
-      else
-        raise CommunitySiteError.new(api_uri, "versions of '#{name}'")
+      # Artifactory responds with a 200 and blank body for unknown cookbooks.
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'") if body.nil?
+
+      body["versions"].collect do |version_uri|
+        self.class.version_from_uri(version_uri)
       end
+
+    rescue Berkshelf::APIClient::ServiceNotFound
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'")
+    rescue
+      raise CommunitySiteError.new(api_uri, "versions of '#{name}'")
     end
 
     # @param [String] name
@@ -176,43 +171,13 @@ module Berkshelf
     #
     # @return [Tempfile]
     def stream(target)
-      local = Tempfile.new('community-rest-stream')
+      local = Tempfile.new("community-rest-stream")
       local.binmode
-
-      Retryable.retryable(tries: retries, on: OpenURI::HTTPError, sleep: retry_interval) do
-        open(target, 'rb', open_uri_options) do |remote|
-          local.write(remote.read)
-        end
+      Retryable.retryable(tries: retries, on: Berkshelf::APIClientError, sleep: retry_interval) do
+        connection.streaming_request(target, {}, local)
       end
-
-      local
     ensure
       local.close(false) unless local.nil?
     end
-
-    private
-
-      def open_uri_options
-        options = {}
-        options.merge!(headers)
-        options.merge!(open_uri_proxy_options)
-		    options.merge!(ssl_verify_mode: ssl_verify_mode)
-      end
-
-      def open_uri_proxy_options
-        if proxy && proxy[:user] && proxy[:password]
-          {proxy_http_basic_authentication: [ proxy[:uri], proxy[:user], proxy[:password] ]}
-        else
-          {}
-        end
-      end
-
-      def ssl_verify_mode
-        if Berkshelf::Config.instance.ssl.verify.nil? || Berkshelf::Config.instance.ssl.verify
-          OpenSSL::SSL::VERIFY_PEER
-        else
-          OpenSSL::SSL::VERIFY_NONE
-        end
-      end
   end
 end

data/lib/berkshelf/config.rb

@@ -1,22 +1,32 @@
-require 'buff/config/json'
-require 'openssl'
+require "mixlib/config" unless defined?(Mixlib::Config)
+require "openssl" unless defined?(OpenSSL)
+
+# we need this method, but have to inject it into mixlib-config directly
+# to have it available from config contexts
+module Mixlib
+  module Config
+    def each(&block)
+      save(true).each(&block)
+    end
+  end
+end
 
 module Berkshelf
-  class Config < Buff::Config::JSON
+  class Config
     class << self
       # @return [String]
       def store_location
-        File.join(Berkshelf.berkshelf_path, 'config.json')
+        File.join(Berkshelf.berkshelf_path, "config.json")
       end
 
       # @return [String]
       def local_location
-        ENV['BERKSHELF_CONFIG'] || File.join('.', '.berkshelf', 'config.json')
+        ENV["BERKSHELF_CONFIG"] || File.join(".", ".berkshelf", "config.json")
       end
 
       # @return [String]
       def path
-        path = File.exists?(local_location) ? local_location : store_location
+        path = File.exist?(local_location) ? local_location : store_location
         File.expand_path(path)
       end
 
@@ -30,22 +40,12 @@ module Berkshelf
         @instance = nil
       end
 
-      # @return [String, nil]
-      #   the contents of the file
-      def file
-        File.read(path) if File.exists?(path)
-      end
-
       # Instantiate and return or just return the currently instantiated Berkshelf
       # configuration
       #
       # @return [Config]
       def instance
-        @instance ||= if file
-          from_json file
-        else
-          new
-        end
+        @instance ||= new(path)
         coerce_ssl
       end
 
@@ -54,131 +54,101 @@ module Berkshelf
       # @return [Config]
       def reload
         @instance = nil
-        self.instance
+        instance
       end
-    
+
       # force proper X509 types from any configuration strings
       #
       # @return [Config]
       def coerce_ssl
-        ssl = @instance.ssl
+        ssl = @instance[:ssl]
         ssl[:ca_cert] = OpenSSL::X509::Certificate.new(File.read(ssl[:ca_cert])) if ssl[:ca_cert] && ssl[:ca_cert].is_a?(String)
         ssl[:client_cert] = OpenSSL::X509::Certificate.new(File.read(ssl[:client_cert])) if ssl[:client_cert] && ssl[:client_cert].is_a?(String)
         ssl[:client_key] = OpenSSL::PKey::RSA.new(File.read(ssl[:client_key])) if ssl[:client_key] && ssl[:client_key].is_a?(String)
         @instance
       end
+
+      def from_file(path)
+        new(path)
+      end
     end
 
+    attr_accessor :path
+
     # @param [String] path
-    # @param [Hash] options
-    #   @see {Buff::Config::JSON}
-    def initialize(path = self.class.path, options = {})
-      super(path, options).tap do
-        # Deprecation
-        if !self.vagrant.omnibus.enabled.nil?
-          Berkshelf.ui.warn "`vagrant.omnibus.enabled' is deprecated and " \
-            "will be removed in a future release. Please remove the " \
-            "`enabled' attribute from your Berkshelf config."
-        end
-        if !self.vagrant.vm.box_url.nil?
-          Berkshelf.ui.warn "`vagrant.vm.box_url' is deprecated and " \
-            "will be removed in a future release. Please remove the " \
-            "`box_url' attribute from your Berkshelf config."
+    def initialize(path = self.class.path)
+      # this is a bit tricky, mixlib-config wants to extend a class and create effectively a global config object while
+      # what we want to do is use an instance, so we create an anonymous class and shove it into an instance variable.
+      # this is actually similar to what mixlib-config itself does to create config contexts.
+      @klass = Class.new
+      @klass.extend(Mixlib::Config)
+      @klass.extend(BerksConfig)
+
+      @path = File.expand_path(path)
+      @klass.from_file(@path) if File.exist?(@path)
+      # yeah, if !File.exist?() you just get back an empty config object
+
+      Berkshelf.ui.warn "The `cookbook.copyright' config is deprecated and will be removed in a future release." unless cookbook.copyright.nil?
+      Berkshelf.ui.warn "The `cookbook.email' config is deprecated and will be removed in a future release." unless cookbook.email.nil?
+      Berkshelf.ui.warn "The `cookbook.license' config is deprecated and will be removed in a future release." unless cookbook.license.nil?
+      Berkshelf.ui.warn "The `vagrant.vm.box' config is deprecated and will be removed in a future release." unless vagrant.vm.box.nil?
+      Berkshelf.ui.warn "The `vagrant.vm.forward_port' config is deprecated and will be removed in a future release." unless vagrant.vm.forward_port.nil?
+      Berkshelf.ui.warn "The `vagrant.vm.provision' config is deprecated and will be removed in a future release." unless vagrant.vm.provision.nil?
+      Berkshelf.ui.warn "The `vagrant.vm.omnibus.version' config is deprecated and will be removed in a future release." unless vagrant.vm.omnibus.version.nil?
+    end
+
+    def method_missing(method, *args, &block)
+      @klass.send(method, *args, &block)
+    end
+
+    module BerksConfig
+      def self.extended(base)
+        base.class_exec do
+          config_strict_mode true
+          config_context :api do
+            default :timeout, "30"
+          end
+          config_context :chef do
+            default :chef_server_url, Berkshelf.chef_config.chef_server_url
+            default :validation_client_name, Berkshelf.chef_config.validation_client_name
+            default :validation_key_path, Berkshelf.chef_config.validation_key
+            default :client_key, Berkshelf.chef_config.client_key
+            default :node_name, Berkshelf.chef_config.node_name
+            default :trusted_certs_dir, Berkshelf.chef_config.trusted_certs_dir
+            default :artifactory_api_key, Berkshelf.chef_config.artifactory_api_key
+          end
+          config_context :cookbook do
+            default :copyright, nil
+            default :email, nil
+            default :license, nil
+          end
+          default :allowed_licenses, []
+          default :raise_license_exception, false
+          config_context :vagrant do
+            config_context :vm do
+              default :box, nil
+              default :forward_port, nil
+              default :provision, nil
+              config_context :omnibus do
+                default :version, nil
+              end
+            end
+          end
+          config_context :ssl do
+            default :verify, true
+            default :cert_store, false
+            default :ca_file, nil
+            default :ca_path, nil
+            default :ca_cert, nil
+            default :client_cert, nil
+            default :client_key, nil
+          end
+          default :github, []
+          default :gitlab, []
+          # :git, :ssh, or :https
+          default :github_protocol, :https
         end
       end
     end
-
-    attribute 'api.timeout',
-      type: String,
-      default: '30'
-    attribute 'chef.chef_server_url',
-      type: String,
-      default: Berkshelf.chef_config.chef_server_url
-    attribute 'chef.validation_client_name',
-      type: String,
-      default: Berkshelf.chef_config.validation_client_name
-    attribute 'chef.validation_key_path',
-      type: String,
-      default: Berkshelf.chef_config.validation_key
-    attribute 'chef.client_key',
-      type: String,
-      default: Berkshelf.chef_config.client_key
-    attribute 'chef.node_name',
-      type: String,
-      default: Berkshelf.chef_config.node_name
-    attribute 'cookbook.copyright',
-      type: String,
-      default: Berkshelf.chef_config.cookbook_copyright
-    attribute 'cookbook.email',
-      type: String,
-      default: Berkshelf.chef_config.cookbook_email
-    attribute 'cookbook.license',
-      type: String,
-      default: Berkshelf.chef_config.cookbook_license
-    attribute 'allowed_licenses',
-      type: Array,
-      default: Array.new
-    attribute 'raise_license_exception',
-      type: Buff::Boolean,
-      default: false
-    attribute 'vagrant.vm.box',
-      type: String,
-      default: 'bento/ubuntu-14.04',
-      required: true
-    # @todo Deprecated, remove?
-    attribute 'vagrant.vm.box_url',
-      type: String,
-      default: nil
-    attribute 'vagrant.vm.forward_port',
-      type: Hash,
-      default: Hash.new
-    attribute 'vagrant.vm.provision',
-      type: String,
-      default: 'chef_solo'
-    # @todo Deprecated, remove. There's a really weird tri-state here where
-    # nil is used to represent an unset value, just FYI
-    attribute 'vagrant.omnibus.enabled',
-      type: Buff::Boolean,
-      default: nil
-    attribute 'vagrant.omnibus.version',
-      type: String,
-      default: 'latest'
-    attribute 'ssl.verify',
-      type: Buff::Boolean,
-      default: true,
-      required: true
-    attribute 'ssl.cert_store',
-      type: Buff::Boolean,
-      default: false,
-      required: false
-    attribute 'ssl.ca_file',
-      type: String,
-      default: nil,
-      required: false
-    attribute 'ssl.ca_path',
-      type: String,
-      default: nil,
-      required: false
-    attribute 'ssl.client_cert',
-      type: String,
-      default: nil,
-      required: false
-    attribute 'ssl.client_key',
-      type: String,
-      default: nil,
-      required: false
-    attribute 'github',
-      type: Array,
-      default: [],
-      required: false
-    attribute 'gitlab',
-      type: Array,
-      default: [],
-      required: false
-    attribute 'github_protocol',
-      # :git, :ssh, or :https
-      type: Symbol,
-      default: :https,
-      required: false
   end
 end

data/lib/berkshelf/cookbook_store.rb

@@ -1,4 +1,5 @@
-require 'fileutils'
+require "fileutils" unless defined?(FileUtils)
+require "chef/exceptions"
 
 module Berkshelf
   class CookbookStore
@@ -7,7 +8,7 @@ module Berkshelf
       #
       # @return [String]
       def default_path
-        File.join(Berkshelf.berkshelf_path, 'cookbooks')
+        File.join(Berkshelf.berkshelf_path, "cookbooks")
       end
 
       # @return [Berkshelf::CookbookStore]
@@ -48,7 +49,7 @@ module Berkshelf
 
     # Destroy the contents of the initialized storage path.
     def clean!
-      FileUtils.rm_rf(Dir.glob(File.join(storage_path, '*')))
+      FileUtils.rm_rf(Dir.glob("#{storage_path}/*"))
     end
 
     # Import a cookbook found on the local filesystem into this instance of the cookbook store.
@@ -65,7 +66,7 @@ module Berkshelf
       destination = cookbook_path(name, version)
       FileUtils.mv(path, destination)
       cookbook(name, version)
-    rescue => ex
+    rescue
       FileUtils.rm_f(destination)
       raise
     end
@@ -106,7 +107,7 @@ module Berkshelf
 
         begin
           CachedCookbook.from_store_path(path)
-        rescue Ridley::Errors::MissingNameAttribute
+        rescue Chef::Exceptions::MetadataNotValid
           # Skip cached cookbooks that do not have a name attribute.
           skipped_cookbooks << File.basename(path)
           next
@@ -162,7 +163,7 @@ module Berkshelf
       graph = Solve::Graph.new
       cookbooks(name).each { |cookbook| graph.artifact(name, cookbook.version) }
 
-      name, version = Solve.it!(graph, [[name, constraint]], ENV['DEBUG_RESOLVER'] ? { ui: Berkshelf.ui } : {}).first
+      name, version = Solve.it!(graph, [[name, constraint]], ENV["DEBUG_RESOLVER"] ? { ui: Berkshelf.ui } : {}).first
 
       cookbook(name, version)
     rescue Solve::Errors::NoSolutionError

data/lib/berkshelf/core_ext/file.rb

@@ -7,7 +7,7 @@ class File
     #
     # @return [Boolean]
     def cookbook?(path)
-      File.exists?(File.join(path, "metadata.json")) || File.exists?(File.join(path, "metadata.rb"))
+      File.exist?(File.join(path, "metadata.json")) || File.exist?(File.join(path, "metadata.rb"))
     end
     alias_method :chef_cookbook?, :cookbook?
   end