berkshelf 6.3.4 → 7.0.0

data/lib/berkshelf/community_rest.rb

@@ -1,9 +1,8 @@
-require "berkshelf/streaming_file_adapter"
 require "retryable"
 require "mixlib/archive"
 
 module Berkshelf
-  class CommunityREST < Faraday::Connection
+  class CommunityREST
     class << self
       # @param [String] target
       #   file path to the tar.gz archive on disk
@@ -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)
+      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.use Berkshelf::StreamingFileAdapter
-      end
-
-      super(api_uri, options)
+      @connection = Berkshelf::RidleyCompatJSON.new(options)
     end
 
     # Download and extract target cookbook archive to the local file system,
@@ -97,79 +89,69 @@ 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 = Dir.chdir(extracted) do
-          Dir.glob("*").find do |dir|
-            File.cookbook?(dir)
-          end
+        Dir.glob("#{extracted}/*").find do |dir|
+          File.cookbook?(dir)
         end
-        File.join(extracted, dir) if dir
       end
     ensure
       archive.unlink unless archive.nil?
     end
 
     def find(name, version)
-      response = get("cookbooks/#{name}/versions/#{self.class.uri_escape_version(version)}")
+      body = connection.get("cookbooks/#{name}/versions/#{self.class.uri_escape_version(version)}")
 
       # Artifactory responds with a 200 and blank body for unknown cookbooks.
-      if response.status == 200 && response.body.to_s == ""
-        response.env.status = 404
-      end
-
-      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
+      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}")
 
       # Artifactory responds with a 200 and blank body for unknown cookbooks.
-      if response.status == 200 && response.body.to_s == ""
-        response.env.status = 404
-      end
+      raise CookbookNotFound.new(name, nil, "at `#{api_uri}'") if body.nil?
 
-      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
+      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
@@ -191,12 +173,9 @@ module Berkshelf
     def stream(target)
       local = Tempfile.new("community-rest-stream")
       local.binmode
-
-      Retryable.retryable(tries: retries, on: Faraday::Error::ConnectionFailed, sleep: retry_interval) do
-        get(target, nil, streaming_file: local)
+      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

data/lib/berkshelf/config.rb

@@ -1,8 +1,18 @@
-require "buff/config/json"
+require "mixlib/config"
 require "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
@@ -16,7 +26,7 @@ module Berkshelf
 
       # @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
 
@@ -33,7 +43,7 @@ module Berkshelf
       # @return [String, nil]
       #   the contents of the file
       def file
-        File.read(path) if File.exists?(path)
+        File.read(path) if File.exist?(path)
       end
 
       # Instantiate and return or just return the currently instantiated Berkshelf
@@ -62,130 +72,94 @@ module Berkshelf
       #
       # @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
+
+      def from_json(json)
+        new.from_json(json)
+      end
+
+      def from_hash(hash)
+        new.from_hash(hash)
+      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 !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 !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
+    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, Berkshelf.chef_config.cookbook_copyright
+            default :email, Berkshelf.chef_config.cookbook_email
+            default :license, Berkshelf.chef_config.cookbook_license
+          end
+          default :allowed_licenses, Array.new
+          default :raise_license_exception, false
+          config_context :vagrant do
+            config_context :vm do
+              default :box, "bento/ubuntu-14.04"
+              default :forward_port, Hash.new
+              default :provision, "chef_solo"
+              config_context :omnibus do
+                default :version, "latest"
+              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 "chef.trusted_certs_dir",
-      type: String,
-      default: Berkshelf.chef_config.trusted_certs_dir
-    attribute "chef.artifactory_api_key",
-      type: String,
-      default: Berkshelf.chef_config.artifactory_api_key
-    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 "chef/exceptions"
 
 module Berkshelf
   class CookbookStore
@@ -67,7 +68,7 @@ module Berkshelf
       destination = cookbook_path(name, version)
       FileUtils.mv(path, destination)
       cookbook(name, version)
-    rescue => ex
+    rescue
       FileUtils.rm_f(destination)
       raise
     end
@@ -108,7 +109,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

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