docker_registry2 1.12.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 869a69624555c180f16132300dfc203787a4e3ffd616f49f26ec7f199b469f1a
-  data.tar.gz: cab7c1746af1ef6956726f42524da542f2ebf9a2fe4a56cc793148aa04a285d4
+  metadata.gz: 6c331456d39ce2a4a57002e7117101f261b2b78bea3b056843430b6c8ccc2110
+  data.tar.gz: 2370009afd0319cfc35a49443e51ad6566508362e5cf3fce941af793c16ac885
 SHA512:
-  metadata.gz: 953669f5e94fef460fe7a3d866964aa76c87a29b2e2285ecb9a85a7058c43317ea1a683aa96e4c23bda450f48805edbc5c681f601ce00a81ae1e93020f6e02c0
-  data.tar.gz: 02fbf888184e024bdf49a62b8b2e4161ae02d1df7f265bbf93aa5e4244fde50221e4fd93e085c291f4333c2ba691ffcc469d016832091c8cb3a286bea39978ba
+  metadata.gz: 32a04a5987fa31cd7feb34d476f82b771e02fd4e5f93caeb4888ad27da0ab7b20cd5cf279f3f06954c599cf68ac930ed9183e5b0410ef90642110bd9ca859b62
+  data.tar.gz: 6ae15951f3f7ca11af1700a701fbc5e270f4adf9a9fb1998bb3657ef85fc79bd1c7cb18e1f9e598e8d592eec9d3c2dfb412d34c7c39fab26b7a3df69585b0dc0

data/docker_registry2.gemspec

@@ -1,5 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'registry/version'
 
@@ -7,24 +8,29 @@ Gem::Specification.new do |spec|
   spec.name          = 'docker_registry2'
   spec.version       = DockerRegistry2::VERSION
   spec.authors       = [
-                         'Avi Deitcher https://github.com/deitch',
-                         'Jonathan Hurter https://github.com/johnsudaar',
-                         'Dmitry Fleytman https://github.com/dmitryfleytman',
-                         'Grey Baker https://github.com/greysteil'
-                       ]
+    'Avi Deitcher https://github.com/deitch',
+    'Jonathan Hurter https://github.com/johnsudaar',
+    'Dmitry Fleytman https://github.com/dmitryfleytman',
+    'Grey Baker https://github.com/greysteil'
+  ]
   spec.summary       = 'Docker v2 registry HTTP API client'
   spec.description   = 'Docker v2 registry HTTP API client with support for token authentication'
   spec.homepage      = 'https://github.com/deitch/docker_registry2'
   spec.license       = 'MIT'
 
-  spec.files         = %w{README.md} + Dir.glob("*.gemspec") + Dir.glob("{lib}/**/*", File::FNM_DOTMATCH).reject { |f| File.directory?(f) }
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.files         = %w[README.md] + Dir.glob('*.gemspec') + Dir.glob('{lib}/**/*', File::FNM_DOTMATCH).reject do |f|
+                                                                 File.directory?(f)
+                                                               end
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'rubocop', '>= 0.26.0'
+  spec.add_development_dependency 'vcr', '~> 6'
+  spec.add_development_dependency 'webmock'
 
   spec.add_dependency 'rest-client', '>= 1.8.0'
 end

data/lib/docker_registry2.rb

@@ -1,13 +1,14 @@
-require File.dirname(__FILE__) + '/registry/version'
-require File.dirname(__FILE__) + '/registry/registry'
-require File.dirname(__FILE__) + '/registry/exceptions'
-require File.dirname(__FILE__) + '/registry/manifest'
-require File.dirname(__FILE__) + '/registry/blob'
+# frozen_string_literal: true
 
+require "#{File.dirname(__FILE__)}/registry/version"
+require "#{File.dirname(__FILE__)}/registry/registry"
+require "#{File.dirname(__FILE__)}/registry/exceptions"
+require "#{File.dirname(__FILE__)}/registry/manifest"
+require "#{File.dirname(__FILE__)}/registry/blob"
 
 module DockerRegistry2
-  def self.connect(uri="https://registry.hub.docker.com",opts={})
-    @reg = DockerRegistry2::Registry.new(uri,opts)
+  def self.connect(uri = 'https://registry.hub.docker.com', opts = {})
+    @reg = DockerRegistry2::Registry.new(uri, opts)
   end
 
   def self.search(query = '')
@@ -18,7 +19,7 @@ module DockerRegistry2
     @reg.tags(repository)
   end
 
-  def self.manifest(repository,tag)
-    @reg.manifest(repository,tag)
+  def self.manifest(repository, tag)
+    @reg.manifest(repository, tag)
   end
 end

data/lib/registry/blob.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module DockerRegistry2
   class Blob
     attr_reader :body, :headers
-    
+
     def initialize(headers, body)
       @headers = headers
       @body = body

data/lib/registry/exceptions.rb

@@ -1,32 +1,33 @@
+# frozen_string_literal: true
+
 module DockerRegistry2
   class Exception < RuntimeError
-    
   end
-  
-  class RegistryAuthenticationException < Exception
+
+  class RegistryAuthenticationException < StandardError
   end
 
-  class RegistryAuthorizationException < Exception
+  class RegistryAuthorizationException < StandardError
   end
 
-  class RegistryUnknownException < Exception
+  class RegistryUnknownException < StandardError
   end
 
-  class RegistrySSLException < Exception
+  class RegistrySSLException < StandardError
   end
 
-  class RegistryVersionException < Exception
+  class RegistryVersionException < StandardError
   end
-  
-  class ReauthenticatedException < Exception
+
+  class ReauthenticatedException < StandardError
   end
-  
-  class UnknownRegistryException < Exception
+
+  class UnknownRegistryException < StandardError
   end
 
-  class NotFound < Exception
+  class NotFound < StandardError
   end
 
-  class InvalidMethod < Exception
+  class InvalidMethod < StandardError
   end
-end
+end

data/lib/registry/manifest.rb

@@ -1,9 +1,8 @@
-module DockerRegistry2
+# frozen_string_literal: true
 
+module DockerRegistry2
+  # Manifest class represents a manfiest or index in an OCI registry
   class Manifest < Hash
     attr_accessor :body, :headers
-    def initialize
-      super
-    end
   end
 end

data/lib/registry/registry.rb

@@ -1,288 +1,291 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'rest-client'
 require 'json'
 
-class DockerRegistry2::Registry
-  # @param [#to_s] base_uri Docker registry base URI
-  # @param [Hash] options Client options
-  # @option options [#to_s] :user User name for basic authentication
-  # @option options [#to_s] :password Password for basic authentication
-  # @option options [#to_s] :open_timeout Time to wait for a connection with a registry.
-  #                                       It is ignored if http_options[:open_timeout] is also specified.
-  # @option options [#to_s] :read_timeout Time to wait for data from a registry.
-  #                                       It is ignored if http_options[:read_timeout] is also specified.
-  # @option options [Hash] :http_options Extra options for RestClient::Request.execute.
-  def initialize(uri, options = {})
-    @uri = URI.parse(uri)
-    @base_uri = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}"
-    @user = options[:user]
-    @password = options[:password]
-    @http_options = options[:http_options] || {}
-    @http_options[:open_timeout] ||= options[:open_timeout] || 2
-    @http_options[:read_timeout] ||= options[:read_timeout] || 5
-  end
+module DockerRegistry2
+  class Registry # rubocop:disable Metrics/ClassLength
+    # @param [#to_s] base_uri Docker registry base URI
+    # @param [Hash] options Client options
+    # @option options [#to_s] :user User name for basic authentication
+    # @option options [#to_s] :password Password for basic authentication
+    # @option options [#to_s] :open_timeout Time to wait for a connection with a registry.
+    #                                       It is ignored if http_options[:open_timeout] is also specified.
+    # @option options [#to_s] :read_timeout Time to wait for data from a registry.
+    #                                       It is ignored if http_options[:read_timeout] is also specified.
+    # @option options [Hash] :http_options Extra options for RestClient::Request.execute.
+    def initialize(uri, options = {})
+      @uri = URI.parse(uri)
+      @base_uri = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}"
+      @user = options[:user]
+      @password = options[:password]
+      @http_options = options[:http_options] || {}
+      @http_options[:open_timeout] ||= options[:open_timeout] || 2
+      @http_options[:read_timeout] ||= options[:read_timeout] || 5
+    end
 
-  def doget(url)
-    return doreq "get", url
-  end
+    def doget(url)
+      doreq 'get', url
+    end
 
-  def doput(url,payload=nil)
-    return doreq "put", url, nil, payload
-  end
+    def doput(url, payload = nil)
+      doreq 'put', url, nil, payload
+    end
 
-  def dodelete(url)
-    return doreq "delete", url
-  end
+    def dodelete(url)
+      doreq 'delete', url
+    end
 
-  def dohead(url)
-    return doreq "head", url
-  end
+    def dohead(url)
+      doreq 'head', url
+    end
 
-  # When a result set is too large, the Docker registry returns only the first items and adds a Link header in the
-  # response with the URL of the next page. See <https://docs.docker.com/registry/spec/api/#pagination>. This method
-  # iterates over the pages and calls the given block with each response.
-  def paginate_doget(url)
-    while url
-      response = doget(url)
-      yield response
+    # When a result set is too large, the Docker registry returns only the first items and adds a Link header in the
+    # response with the URL of the next page. See <https://docs.docker.com/registry/spec/api/#pagination>. This method
+    # iterates over the pages and calls the given block with each response.
+    def paginate_doget(url)
+      loop do
+        response = doget(url)
+        yield response
 
-      if (link = response.headers[:link])
-        url = parse_link_header(link)[:next]
-      else
-        break
+        link_header = response.headers[:link]
+        break unless link_header
+
+        url = parse_link_header(link_header)[:next]
       end
     end
-  end
 
-  def search(query = '')
-    all_repos = []
-    paginate_doget "/v2/_catalog" do |response|
-      # parse the response
-      repos = JSON.parse(response)["repositories"]
-      if query.strip.length > 0
-        re = Regexp.new query
-        repos = repos.find_all {|e| re =~ e }
+    def search(query = '')
+      all_repos = []
+      paginate_doget('/v2/_catalog') do |response|
+        repos = JSON.parse(response)['repositories']
+        repos.select! { |repo| repo.match?(/#{query}/) } unless query.empty?
+        all_repos += repos
       end
-      all_repos += repos
+      all_repos
     end
-    all_repos
-  end
 
-  def tags(repo,count=nil,last="",withHashes = false, auto_paginate: false)
-    #create query params
-    params = []
-    params.push(["last",last]) if last && last != ""
-    params.push(["n",count]) unless count.nil?
-
-    query_vars = ""
-    query_vars = "?#{URI.encode_www_form(params)}" if params.length > 0
-
-    response = doget "/v2/#{repo}/tags/list#{query_vars}"
-    # parse the response
-    resp = JSON.parse response
-    # parse out next page link if necessary
-    resp["last"] = last(response.headers[:link]) if response.headers[:link]
-
-    # do we include the hashes?
-    if withHashes
-      useGet = false
-      resp["hashes"] = {}
-      resp["tags"].each do |tag|
-        if useGet
-          head = doget "/v2/#{repo}/manifests/#{tag}"
-        else
-          begin
-            head = dohead "/v2/#{repo}/manifests/#{tag}"
-          rescue DockerRegistry2::InvalidMethod
-            # in case we are in a registry pre-2.3.0, which did not support manifest HEAD
-            useGet = true
+    def tags(repo, count = nil, last = '', withHashes = false, auto_paginate: false)
+      # create query params
+      params = []
+      params.push(['last', last]) if last && last != ''
+      params.push(['n', count]) unless count.nil?
+
+      query_vars = ''
+      query_vars = "?#{URI.encode_www_form(params)}" if params.length.positive?
+
+      response = doget "/v2/#{repo}/tags/list#{query_vars}"
+      # parse the response
+      resp = JSON.parse response
+      # parse out next page link if necessary
+      resp['last'] = last(response.headers[:link]) if response.headers[:link]
+
+      # do we include the hashes?
+      if withHashes
+        useGet = false
+        resp['hashes'] = {}
+        resp['tags'].each do |tag|
+          if useGet
             head = doget "/v2/#{repo}/manifests/#{tag}"
+          else
+            begin
+              head = dohead "/v2/#{repo}/manifests/#{tag}"
+            rescue DockerRegistry2::InvalidMethod
+              # in case we are in a registry pre-2.3.0, which did not support manifest HEAD
+              useGet = true
+              head = doget "/v2/#{repo}/manifests/#{tag}"
+            end
           end
+          resp['hashes'][tag] = head.headers[:docker_content_digest]
         end
-        resp["hashes"][tag] = head.headers[:docker_content_digest]
       end
-    end
 
-    return resp unless auto_paginate
+      return resp unless auto_paginate
+
+      while (last_tag = resp.delete('last'))
+        additional_tags = tags(repo, count, last_tag, withHashes)
+        resp['last'] = additional_tags['last']
+        resp['tags'] += additional_tags['tags']
+        resp['tags'] = resp['tags'].uniq
+        resp['hashes'].merge!(additional_tags['hashes']) if withHashes
+      end
 
-    while (last_tag = resp.delete("last"))
-      additional_tags = tags(repo, count, last_tag, withHashes)
-      resp["last"] = additional_tags["last"]
-      resp["tags"] += additional_tags["tags"]
-      resp["tags"] = resp["tags"].uniq
-      resp["hashes"].merge!(additional_tags["hashes"]) if withHashes
+      resp
     end
 
-    resp
-  end
+    def manifest(repo, tag)
+      # first get the manifest
+      response = doget "/v2/#{repo}/manifests/#{tag}"
+      parsed = JSON.parse response.body
+      manifest = DockerRegistry2::Manifest[parsed]
+      manifest.body = response.body
+      manifest.headers = response.headers
+      manifest
+    end
 
-  def manifest(repo,tag)
-    # first get the manifest
-    response = doget "/v2/#{repo}/manifests/#{tag}"
-    parsed = JSON.parse response.body
-    manifest = DockerRegistry2::Manifest[parsed]
-    manifest.body = response.body
-    manifest.headers = response.headers
-    manifest
-  end
+    def blob(repo, digest, outpath = nil)
+      blob_url = "/v2/#{repo}/blobs/#{digest}"
+      if outpath.nil?
+        response = doget(blob_url)
+        DockerRegistry2::Blob.new(response.headers, response.body)
+      else
+        File.open(outpath, 'w') do |fd|
+          doreq('get', blob_url, fd)
+        end
 
-  def blob(repo, digest, outpath=nil)
-    blob_url = "/v2/#{repo}/blobs/#{digest}"
-    if outpath.nil?
-      response = doget(blob_url)
-      DockerRegistry2::Blob.new(response.headers, response.body)
-    else
-      File.open(outpath, 'w') do |fd|
-        doreq('get', blob_url, fd)
+        outpath
       end
-
-      outpath
     end
-  end
 
-  def digest(repo, tag)
-    tag_path = "/v2/#{repo}/manifests/#{tag}"
-    dohead(tag_path).headers[:docker_content_digest]
-  rescue DockerRegistry2::InvalidMethod
-    # Pre-2.3.0 registries didn't support manifest HEAD requests
-    doget(tag_path).headers[:docker_content_digest]
-  end
+    def digest(repo, tag)
+      tag_path = "/v2/#{repo}/manifests/#{tag}"
+      dohead(tag_path).headers[:docker_content_digest]
+    rescue DockerRegistry2::InvalidMethod
+      # Pre-2.3.0 registries didn't support manifest HEAD requests
+      doget(tag_path).headers[:docker_content_digest]
+    end
 
-  def rmtag(image, tag)
-    # TODO: Need full response back. Rewrite other manifests() calls without JSON?
-    reference = doget("/v2/#{image}/manifests/#{tag}").headers[:docker_content_digest]
+    def rmtag(image, tag)
+      # TODO: Need full response back. Rewrite other manifests() calls without JSON?
+      reference = doget("/v2/#{image}/manifests/#{tag}").headers[:docker_content_digest]
 
-    return dodelete("/v2/#{image}/manifests/#{reference}").code
-  end
+      dodelete("/v2/#{image}/manifests/#{reference}").code
+    end
 
-  def pull(repo, tag, dir)
-    # make sure the directory exists
-    FileUtils.mkdir_p dir
-    # get the manifest
-    m = manifest repo, tag
-    # puts "pulling #{repo}:#{tag} into #{dir}"
-    # manifest can contain multiple manifests one for each API version
-    downloaded_layers = []
-    downloaded_layers += _pull_v2(repo, m, dir) if m['schemaVersion'] == 2
-    downloaded_layers += _pull_v1(repo, m, dir) if m['schemaVersion'] == 1
-    # return downloaded_layers
-    downloaded_layers
-  end
+    def pull(repo, tag, dir)
+      # make sure the directory exists
+      FileUtils.mkdir_p dir
+      # get the manifest
+      m = manifest repo, tag
+      # puts "pulling #{repo}:#{tag} into #{dir}"
+      # manifest can contain multiple manifests one for each API version
+      downloaded_layers = []
+      downloaded_layers += _pull_v2(repo, m, dir) if m['schemaVersion'] == 2
+      downloaded_layers += _pull_v1(repo, m, dir) if m['schemaVersion'] == 1
+      # return downloaded_layers
+      downloaded_layers
+    end
 
-  def _pull_v2(repo, manifest, dir)
-    # make sure the directory exists
-    FileUtils.mkdir_p dir
-    return false unless manifest['schemaVersion'] == 2
-    # pull each of the layers
-    manifest['layers'].each do |layer|
-      # define path of file to save layer in
-      layer_file = "#{dir}/#{layer['digest']}"
-      # skip layer if we already got it
-      next if File.file? layer_file
-      # download layer
-      # puts "getting layer (v2) #{layer['digest']}"
-      blob(repo, layer['digest'], layer_file)
-      layer_file
+    def _pull_v2(repo, manifest, dir)
+      # make sure the directory exists
+      FileUtils.mkdir_p dir
+      return false unless manifest['schemaVersion'] == 2
+
+      # pull each of the layers
+      manifest['layers'].each do |layer|
+        # define path of file to save layer in
+        layer_file = "#{dir}/#{layer['digest']}"
+        # skip layer if we already got it
+        next if File.file? layer_file
+
+        # download layer
+        # puts "getting layer (v2) #{layer['digest']}"
+        blob(repo, layer['digest'], layer_file)
+        layer_file
+      end
     end
-  end
 
-  def _pull_v1(repo, manifest, dir)
-    # make sure the directory exists
-    FileUtils.mkdir_p dir
-    return false unless manifest['schemaVersion'] == 1
-    # pull each of the layers
-    manifest['fsLayers'].each do |layer|
-      # define path of file to save layer in
-      layer_file = "#{dir}/#{layer['blobSum']}"
-      # skip layer if we already got it
-      next if File.file? layer_file
-      # download layer
-      # puts "getting layer (v1) #{layer['blobSum']}"
-      blob(repo, layer['blobSum'], layer_file)
-      # return layer file
-      layer_file
+    def _pull_v1(repo, manifest, dir)
+      # make sure the directory exists
+      FileUtils.mkdir_p dir
+      return false unless manifest['schemaVersion'] == 1
+
+      # pull each of the layers
+      manifest['fsLayers'].each do |layer|
+        # define path of file to save layer in
+        layer_file = "#{dir}/#{layer['blobSum']}"
+        # skip layer if we already got it
+        next if File.file? layer_file
+
+        # download layer
+        # puts "getting layer (v1) #{layer['blobSum']}"
+        blob(repo, layer['blobSum'], layer_file)
+        # return layer file
+        layer_file
+      end
     end
-  end
 
-  def push(manifest,dir)
-  end
+    def push(manifest, dir); end
+
+    def tag(repo, tag, newrepo, newtag)
+      manifest = manifest(repo, tag)
 
-  def tag(repo,tag,newrepo,newtag)
-    manifest = manifest(repo, tag)
+      raise DockerRegistry2::RegistryVersionException unless manifest['schemaVersion'] == 2
 
-    if manifest['schemaVersion'] == 2
       doput "/v2/#{newrepo}/manifests/#{newtag}", manifest.to_json
-    else
-      raise DockerRegistry2::RegistryVersionException
     end
-  end
 
-  def copy(repo,tag,newregistry,newrepo,newtag)
-  end
+    def copy(repo, tag, newregistry, newrepo, newtag); end
 
-  # gets the size of a particular blob, given the repo and the content-addressable hash
-  # usually unneeded, since manifest includes it
-  def blob_size(repo,blobSum)
-    response = dohead "/v2/#{repo}/blobs/#{blobSum}"
-    Integer(response.headers[:content_length],10)
-  end
+    # gets the size of a particular blob, given the repo and the content-addressable hash
+    # usually unneeded, since manifest includes it
+    def blob_size(repo, blobSum)
+      response = dohead "/v2/#{repo}/blobs/#{blobSum}"
+      Integer(response.headers[:content_length], 10)
+    end
+
+    # Parse the value of the Link HTTP header and return a Hash whose keys are the rel values turned into symbols, and
+    # the values are URLs. For example, `{ next: '/v2/_catalog?n=100&last=x' }`.
+    def parse_link_header(header)
+      last = ''
+      parts = header.split(',')
+      links = {}
+
+      # Parse each part into a named link
+      parts.each do |part, _index|
+        section = part.split(';')
+        url = section[0][/<(.*)>/, 1]
+        name = section[1][/rel="?([^"]*)"?/, 1].to_sym
+        links[name] = url
+      end
 
-  # Parse the value of the Link HTTP header and return a Hash whose keys are the rel values turned into symbols, and
-  # the values are URLs. For example, `{ next: '/v2/_catalog?n=100&last=x' }`.
-  def parse_link_header(header)
-    last=''
-    parts = header.split(',')
-    links = Hash.new
-
-    # Parse each part into a named link
-    parts.each do |part, index|
-      section = part.split(';')
-      url = section[0][/<(.*)>/,1]
-      name = section[1][/rel="?([^"]*)"?/,1].to_sym
-      links[name] = url
+      links
     end
 
-    links
-  end
+    def last(header)
+      links = parse_link_header(header)
+      if links[:next]
+        query = URI(links[:next]).query
+        link_key = @uri.host.eql?('quay.io') ? 'next_page' : 'last'
+        last = URI.decode_www_form(query).to_h[link_key]
 
-  def last(header)
-    links = parse_link_header(header)
-    if links[:next]
-      query=URI(links[:next]).query
-      link_key = @uri.host.eql?('quay.io') ? 'next_page' : 'last'
-      last=URI::decode_www_form(query).to_h[link_key]
+      end
+      last
+    end
 
+    def manifest_sum(manifest)
+      size = 0
+      manifest['layers'].each do |layer|
+        size += layer['size']
+      end
+      size
     end
-    last
-  end
 
-  def manifest_sum(manifest)
-    size = 0
-    manifest["layers"].each { |layer|
-      size += layer["size"]
-    }
-    size
-  end
+    private
 
-  private
-    def doreq(type,url,stream=nil,payload=nil)
+    def doreq(type, url, stream = nil, payload = nil)
       begin
-        block = stream.nil? ? nil : proc { |response|
-          response.read_body do |chunk|
-            stream.write chunk
-          end
-        }
+        block = if stream.nil?
+                  nil
+                else
+                  proc { |response|
+                    response.read_body do |chunk|
+                      stream.write chunk
+                    end
+                  }
+                end
         response = RestClient::Request.execute(@http_options.merge(
-          method: type,
-          url: @base_uri+url,
-          headers: headers(payload: payload),
-          block_response: block,
-          payload: payload
-        ))
+                                                 method: type,
+                                                 url: @base_uri + url,
+                                                 headers: headers(payload: payload),
+                                                 block_response: block,
+                                                 payload: payload
+                                               ))
       rescue SocketError
         raise DockerRegistry2::RegistryUnknownException
-      rescue RestClient::NotFound => error
-        raise DockerRegistry2::NotFound, error
+      rescue RestClient::NotFound
+        raise DockerRegistry2::NotFound, "Image not found at #{@uri.host}"
       rescue RestClient::Unauthorized => e
         header = e.response.headers[:www_authenticate]
         method = header.to_s.downcase.split(' ')[0]
@@ -295,96 +298,102 @@ class DockerRegistry2::Registry
           raise DockerRegistry2::RegistryUnknownException
         end
       end
-      return response
+      response
     end
 
-    def do_basic_req(type, url, stream=nil, payload=nil)
+    def do_basic_req(type, url, stream = nil, payload = nil)
       begin
-        block = stream.nil? ? nil : proc { |response|
-          response.read_body do |chunk|
-            stream.write chunk
-          end
-        }
+        block = if stream.nil?
+                  nil
+                else
+                  proc { |response|
+                    response.read_body do |chunk|
+                      stream.write chunk
+                    end
+                  }
+                end
         response = RestClient::Request.execute(@http_options.merge(
-          method: type,
-          url: @base_uri+url,
-          user: @user,
-          password: @password,
-          headers: headers(payload: payload),
-          block_response: block,
-          payload: payload
-        ))
+                                                 method: type,
+                                                 url: @base_uri + url,
+                                                 user: @user,
+                                                 password: @password,
+                                                 headers: headers(payload: payload),
+                                                 block_response: block,
+                                                 payload: payload
+                                               ))
       rescue SocketError
         raise DockerRegistry2::RegistryUnknownException
       rescue RestClient::Unauthorized
         raise DockerRegistry2::RegistryAuthenticationException
       rescue RestClient::MethodNotAllowed
         raise DockerRegistry2::InvalidMethod
-      rescue RestClient::NotFound => error
-        raise DockerRegistry2::NotFound, error
+      rescue RestClient::NotFound => e
+        raise DockerRegistry2::NotFound, e
       end
-      return response
+      response
     end
 
-    def do_bearer_req(type, url, header, stream=false, payload=nil)
+    def do_bearer_req(type, url, header, stream = false, payload = nil)
       token = authenticate_bearer(header)
       begin
-        block = stream.nil? ? nil : proc { |response|
-          response.read_body do |chunk|
-            stream.write chunk
-          end
-        }
+        block = if stream.nil?
+                  nil
+                else
+                  proc { |response|
+                    response.read_body do |chunk|
+                      stream.write chunk
+                    end
+                  }
+                end
         response = RestClient::Request.execute(@http_options.merge(
-          method: type,
-          url: @base_uri+url,
-          headers: headers(payload: payload, bearer_token: token),
-          block_response: block,
-          payload: payload
-        ))
+                                                 method: type,
+                                                 url: @base_uri + url,
+                                                 headers: headers(payload: payload, bearer_token: token),
+                                                 block_response: block,
+                                                 payload: payload
+                                               ))
       rescue SocketError
         raise DockerRegistry2::RegistryUnknownException
       rescue RestClient::Unauthorized
         raise DockerRegistry2::RegistryAuthenticationException
       rescue RestClient::MethodNotAllowed
         raise DockerRegistry2::InvalidMethod
-      rescue RestClient::NotFound => error
-        raise DockerRegistry2::NotFound, error
+      rescue RestClient::NotFound => e
+        raise DockerRegistry2::NotFound, e
       end
 
-      return response
+      response
     end
 
     def authenticate_bearer(header)
       # get the parts we need
       target = split_auth_header(header)
       # did we have a username and password?
-      if defined? @user and @user.to_s.strip.length != 0
-        target[:params][:account] = @user
-      end
+      target[:params][:account] = @user if defined? @user && !@user.to_s.strip.empty?
       # authenticate against the realm
       uri = URI.parse(target[:realm])
       begin
         response = RestClient::Request.execute(@http_options.merge(
-          method: :get,
-          url: uri.to_s, headers: {params: target[:params]},
-          user: @user,
-          password: @password,
-        ))
+                                                 method: :get,
+                                                 url: uri.to_s, headers: { params: target[:params] },
+                                                 user: @user,
+                                                 password: @password
+                                               ))
       rescue RestClient::Unauthorized, RestClient::Forbidden
         # bad authentication
         raise DockerRegistry2::RegistryAuthenticationException
-      rescue RestClient::NotFound => error
-        raise DockerRegistry2::NotFound, error
+      rescue RestClient::NotFound => e
+        raise DockerRegistry2::NotFound, e
       end
       # now save the web token
       result = JSON.parse(response)
-      return result["token"] || result["access_token"]
+      result['token'] || result['access_token']
     end
 
     def split_auth_header(header = '')
-      h = Hash.new
-      h = {params: {}}
-      header.scan(/([\w]+)\=\"([^"]+)\"/) do |entry|
+      h = {}
+      h = { params: {} }
+      header.scan(/(\w+)="([^"]+)"/) do |entry|
         case entry[0]
         when 'realm'
           h[:realm] = entry[1]
@@ -396,11 +405,19 @@ class DockerRegistry2::Registry
     end
 
     def headers(payload: nil, bearer_token: nil)
-      headers={}
-      headers['Authorization']="Bearer #{bearer_token}" unless bearer_token.nil?
-      headers['Accept']='application/vnd.docker.distribution.manifest.v2+json, application/json' if payload.nil?
-      headers['Content-Type']='application/vnd.docker.distribution.manifest.v2+json' unless payload.nil?
+      headers = {}
+      headers['Authorization'] = "Bearer #{bearer_token}" unless bearer_token.nil?
+      if payload.nil?
+        headers['Accept'] =
+          %w[application/vnd.docker.distribution.manifest.v2+json
+             application/vnd.docker.distribution.manifest.list.v2+json
+             application/vnd.oci.image.manifest.v1+json
+             application/vnd.oci.image.index.v1+json
+             application/json].join(',')
+      end
+      headers['Content-Type'] = 'application/vnd.docker.distribution.manifest.v2+json' unless payload.nil?
 
       headers
     end
+  end
 end

data/lib/registry/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DockerRegistry2
-  VERSION = '1.12.0'
+  VERSION = '1.14.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker_registry2
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.14.0
 platform: ruby
 authors:
 - Avi Deitcher https://github.com/deitch
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-23 00:00:00.000000000 Z
+date: 2023-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -41,6 +41,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -55,6 +69,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.26.0
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -102,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: Docker v2 registry HTTP API client