tagfish 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 801be00ea36e0cc2c98c535546c45f1025768ca0
-  data.tar.gz: 9ce46a51783f66f42f9da2f4d5a5cebc6e459fd4
+  metadata.gz: 45ed3de3aea63c3fbb5108caa65a5e4f13fce18b
+  data.tar.gz: 58afb32647d0002ae0af805e7e13812f48b96220
 SHA512:
-  metadata.gz: ad70b423105855d754bed1ad62d9291dbc18ac4ce113e38e3825aa72765d792572767a6f3df90f2c20c0af5677358cc9281f6499dbb49fb303e5ca312740c182
-  data.tar.gz: 33dbd5a8faf479d8a10364b7980731bb9c1823915d4aab0d08a4ac6d3a018fde857b22c22c950359bce3c2086fb9fd58eb92dafc358bb3580a753b5bc2ce6efe
+  metadata.gz: cfda8b965954cef8c83dd908ed315a067898a0e5143675a95fe6369c11ab64a83f19495c290a24432482b6179391fb6e673e75f9e1b0a2622f014c8cda42ae71
+  data.tar.gz: 9cf24c63a9a82178dc03a33918264993a5d3bcdfd6e254ef525da9fc5ec3fd16ef9da232e6409236533174a5eb2b2ea19c50b53daeda67a1edac917fb3376cf1

data/Dockerfile

@@ -11,7 +11,7 @@ RUN apk add --update ruby=2.2.3-r1 \
     rm /var/cache/apk/* && \
     rm -rf /usr/share/ri
 
-RUN echo -e 'gem: --no-rdoc --no-ri' > /etc/gemrc \
+RUN echo -e 'gem: --no-rdoc --no-ri' > /etc/gemrc && \
     gem update --system 2.4.8 && \
     gem install bundler -v 1.10.6 && \
     rm -rf /usr/share/ri

data/lib/tagfish/docker_registry_client.rb

@@ -0,0 +1,24 @@
+require 'tagfish/docker_registry_v1_client'
+require 'tagfish/docker_registry_v2_client'
+
+module Tagfish
+  module DockerRegistryClient
+
+    def self.for(*args)
+      [DockerRegistryV2Client, DockerRegistryV1Client].each do |client_class|
+        begin 
+          return client_class.new(*args)
+        rescue APIVersionError
+        end
+      end
+      raise APIVersionError, "API version unrecognized!"
+    end
+    
+    class AuthenticationError < StandardError
+    end
+    
+    class APIVersionError < StandardError
+    end
+    
+  end
+end

data/lib/tagfish/docker_registry_v1_client.rb

@@ -0,0 +1,54 @@
+require 'tagfish/docker_registry_vboth_client'
+
+module Tagfish
+  class DockerRegistryV1Client < DockerRegistryVbothClient
+    
+    def api_version
+      'v1'
+    end
+    
+    def search(keyword)
+      APICall.new(search_uri(keyword)).get_json(http_auth)
+    end
+    
+    def tag_names
+      tag_map.tag_names
+    end
+
+    def tag_map
+      tags_list = tags_api(tags)
+      Tagfish::Tags.new(tags_list)
+    end
+    
+    private
+
+    def tags
+      APICall.new(tags_uri).get_json(http_auth)
+    end
+        
+    def tags_api(api_response_data)
+      case api_response_data
+        when Hash
+        api_response_data
+      when Array
+        api_response_data.reduce({}) do |images, tag|
+          images.merge({tag["name"] => tag["layer"]})
+        end
+      else
+        raise "unexpected type #{api_response_data.class}"
+      end
+    end
+    
+    def ping_uri
+      "#{base_uri}/v1/_ping"
+    end
+    
+    def search_uri(keyword)
+      "#{base_uri}/v1/search?q=#{keyword}"  
+    end
+    
+    def tags_uri
+      "#{base_uri}/v1/repositories/#{docker_uri.repository}/tags"
+    end
+  end
+end

data/lib/tagfish/docker_registry_v2_client.rb

@@ -0,0 +1,59 @@
+require 'tagfish/docker_registry_vboth_client'
+
+module Tagfish
+  class DockerRegistryV2Client < DockerRegistryVbothClient
+    
+    def api_version
+      'v2'
+    end
+    
+    def catalog
+      APICall.new(catalog_uri).get_json(http_auth)
+    end
+    
+    def tag_names
+      tags["tags"]
+    end
+
+    def tag_map
+      Tagfish::Tags.new(tags_logic)
+    end
+
+    private
+    
+    def tags
+      APICall.new(tags_uri).get_json(http_auth)
+    end
+    
+    def hash(tag)
+      APICall.new(hash_uri(tag)).get_json(http_auth)
+    end
+    
+    def tags_logic
+      if tag_names.nil?
+        abort("No Tags found for this repository")
+      end
+      
+      tags_with_hashes = tag_names.inject({}) do |dict, tag|
+        dict[tag] = hash(tag)["fsLayers"]
+        dict
+      end
+    end
+      
+    def ping_uri
+      "#{base_uri}/v2/"
+    end
+
+    def catalog_uri
+      "#{base_uri}/v2/_catalog"
+    end
+    
+    def tags_uri
+      "#{base_uri}/v2/#{docker_uri.repository}/tags/list"  
+    end
+    
+    def hash_uri(tag)
+      "#{base_uri}/v2/#{docker_uri.repository}/manifests/#{tag}"
+    end
+  end
+end

data/lib/tagfish/docker_registry_vboth_client.rb

@@ -0,0 +1,32 @@
+require 'net/http'
+require 'json'
+require 'tagfish/docker_uri'
+require 'tagfish/api_call'
+require 'tagfish/tags'
+
+module Tagfish
+  class DockerRegistryVbothClient
+
+    attr_accessor :docker_uri
+    attr_accessor :http_auth
+
+    def initialize(docker_uri)
+      @docker_uri = docker_uri
+      code = APICall.new(ping_uri).response_code
+      if code == 401
+        @http_auth = DockerHttpAuth.new(docker_uri.registry)
+        code = APICall.new(ping_uri).response_code(http_auth)
+      end
+      if code == 401
+        raise DockerRegistryClient::AuthenticationError, "Please `docker login <REGISTRY>` and try again"
+      elsif code != 200
+        raise DockerRegistryClient::APIVersionError, "Not recognized"
+      end
+    end
+    
+    def base_uri
+      "#{docker_uri.protocol}#{docker_uri.registry}"
+    end
+
+  end
+end

data/lib/tagfish/docker_uri.rb

@@ -1,5 +1,4 @@
 require 'tagfish/docker_http_auth'
-require 'tagfish/docker_api'
 
 module Tagfish
   class DockerURI

data/lib/tagfish/search_command.rb

@@ -14,19 +14,26 @@ module Tagfish
       docker_api = DockerAPI.new(docker_uri)
       
       if docker_api.api_version == 'v2'
-        repos = docker_api.catalog_v2["repositories"]
-        if keyword
-          repos.select! {|repo| repo.include? keyword}
-        end
-        repos.each {|repo| puts "#{docker_uri.registry}/#{repo}"} 
-      else # 'v1'
-        if not keyword
-          abort("You need to specify a keyword to search a Registry V1")
-        end
-        repos_raw = docker_api.search_v1(keyword)
-        repos = repos_raw["results"].map {|result| result["name"]}
-        puts repos
+        puts search_v2(keyword, docker_api, docker_uri)
+      else
+        puts search_v1(keyword, docker_api)
       end
     end
+    
+    def search_v2(keyword, docker_api, docker_uri)
+      repos = docker_api.catalog_v2["repositories"]
+      if keyword
+        repos.select! {|repo| repo.include? keyword}
+      end
+      repos.map {|repo| "#{docker_uri.registry}/#{repo}"} 
+    end
+    
+    def search_v1(keyword, docker_api)
+      if not keyword
+        abort("You need to specify a keyword to search a Registry V1")
+      end
+      repos_raw = docker_api.search_v1(keyword)
+      repos = repos_raw["results"].map {|result| result["name"]}
+    end
   end
 end

data/lib/tagfish/tags.rb

@@ -4,23 +4,21 @@ require 'json'
 module Tagfish
   class Tags
 
-    def initialize(tags)
-      @tags = tags
+    attr_reader :tag_map 
+    
+    def initialize(tag_map)
+      @tag_map = tag_map
     end
 
     def tag_names
-      @tags.keys.sort
+      tag_map.keys.sort
     end
 
     def latest_tag
-      tag_names.select do |tag_name|
-        (@tags[tag_name] == @tags["latest"]) && (tag_name != 'latest')
+      tag_names.detect do |tag_name|
+        (tag_map[tag_name] == tag_map["latest"]) && (tag_name != "latest")
       end
     end
 
-    def latest_tag_to_s
-      latest_tag.empty? ? nil : latest_tag[0]
-    end
-
   end
 end

data/lib/tagfish/tags_command.rb

@@ -1,5 +1,5 @@
-require "tagfish/tags_logic"
 require "tagfish/docker_uri"
+require "tagfish/docker_registry_client"
 
 module Tagfish
   class TagsCommand < Clamp::Command
@@ -8,23 +8,20 @@ module Tagfish
     option ["-s", "--short"], :flag, "only return tag, not full image path"
 
     def execute
-      tags_only = latest? ? false : true
       
       docker_uri = DockerURI.parse(repository)
-      docker_api = DockerAPI.new(docker_uri)
-      tags = TagsLogic.find_tags_by_repository(docker_api, tags_only)
-
-      begin
-       tags_found = latest? ? tags.latest_tag : tags.tag_names
-      rescue Exception => e
-        puts e.message
-        return
-      end
-
-      if tags_found.size == 0
-        puts "ERROR: No image explicitly tagged in this Repository, " +
-                "only `latest` tag available."
-        return
+      docker_api = DockerRegistryClient.for(docker_uri)
+      
+      if latest?
+        tags = docker_api.tag_map
+        latest_tag = tags.latest_tag
+        if latest_tag.nil?
+          signal_error "No image explicitly tagged in this Repository, " +
+                  "only `latest` tag available."
+        end
+        tags_found = [latest_tag]
+      else
+        tags_found = docker_api.tag_names
       end
 
       pretty_tags = tags_found.map do |tag_name|

data/lib/tagfish/update/updater.rb

@@ -1,6 +1,6 @@
 require 'tagfish/tokeniser'
 require 'tagfish/docker_uri'
-require 'tagfish/tags_logic'
+require 'tagfish/docker_registry_client'
 
 module Tagfish
   module Update
@@ -38,9 +38,9 @@ module Tagfish
       end
 
       def update_uri(docker_uri)
-        docker_api = DockerAPI.new(docker_uri)
-        tags = TagsLogic.find_tags_by_repository(docker_api)
-        newest_tag_name = tags.latest_tag_to_s
+        docker_api = DockerRegistryClient.for(docker_uri)
+        tags = docker_api.tag_map
+        newest_tag_name = tags.latest_tag
         if newest_tag_name.nil?
           docker_uri
         else

data/lib/tagfish/version.rb

@@ -1,3 +1,3 @@
 module Tagfish
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tagfish
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Clement Labbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-15 00:00:00.000000000 Z
+date: 2016-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -110,13 +110,15 @@ files:
 - bin/tagfish
 - lib/tagfish.rb
 - lib/tagfish/api_call.rb
-- lib/tagfish/docker_api.rb
 - lib/tagfish/docker_http_auth.rb
+- lib/tagfish/docker_registry_client.rb
+- lib/tagfish/docker_registry_v1_client.rb
+- lib/tagfish/docker_registry_v2_client.rb
+- lib/tagfish/docker_registry_vboth_client.rb
 - lib/tagfish/docker_uri.rb
 - lib/tagfish/search_command.rb
 - lib/tagfish/tags.rb
 - lib/tagfish/tags_command.rb
-- lib/tagfish/tags_logic.rb
 - lib/tagfish/tokeniser.rb
 - lib/tagfish/update/differ.rb
 - lib/tagfish/update/update_command.rb
@@ -145,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Command line utility for docker registries

data/lib/tagfish/docker_api.rb

@@ -1,113 +0,0 @@
-require 'net/http'
-require 'json'
-require 'tagfish/docker_uri'
-require 'tagfish/api_call'
-
-module Tagfish
-  class DockerAPI
-
-    attr_accessor :docker_uri
-    attr_accessor :api_version
-    attr_accessor :http_auth
-
-    def initialize(docker_uri)
-      @docker_uri = docker_uri
-      retrieve_api_version_and_auth()
-    end
-    
-    def retrieve_api_version_and_auth
-      code = try_api('v1')
-      if code != 200 
-        code = try_api('v2')
-      end
-      if code == 401
-        abort("Authentication failed, please `docker login <REGISTRY>` and try again.")
-      elsif code != 200
-        abort("API version not recognized")
-      end
-    end
-    
-    def try_api(version)
-      code = APICall.new(ping_uri(version)).response_code
-      if code == 200
-        @api_version = version
-      elsif code == 401
-        code = init_auth(version)
-        if code == 200
-          @api_version = version
-        end
-      end
-      return code
-    end
-    
-    def init_auth(api_version)
-      @http_auth = DockerHttpAuth.new(docker_uri.registry)
-      if api_version == 'v2'
-        code = APICall.new(ping_v2_uri).response_code(http_auth)
-      elsif api_version == 'v1'
-        code = APICall.new(ping_v1_uri).response_code(http_auth)
-      end
-    end
-    
-    def tags_v1
-      APICall.new(tags_v1_uri).get_json(http_auth)
-    end
-    
-    def tags_v2
-      APICall.new(tags_v2_uri).get_json(http_auth)
-    end
-    
-    def hash_v2(tag)
-      APICall.new(hash_v2_uri(tag)).get_json(http_auth)
-    end
-    
-    def catalog_v2
-      APICall.new(catalog_v2_uri).get_json(http_auth)
-    end
-    
-    def search_v1(keyword)
-      APICall.new(search_v1_uri(keyword)).get_json(http_auth)
-    end
-    
-    def base_uri
-      "#{docker_uri.protocol}#{docker_uri.registry}"
-    end
-    
-    def ping_uri(version)
-      if version == 'v1'
-        ping_v1_uri
-      elsif version == 'v2'
-        ping_v2_uri
-      end
-    end
-    
-    def ping_v2_uri
-      "#{base_uri}/v2/"
-    end
-    
-    def ping_v1_uri
-      "#{base_uri}/v1/_ping"
-    end
-    
-    def catalog_v2_uri
-      "#{base_uri}/v2/_catalog"
-    end
-    
-    def search_v1_uri(keyword)
-      "#{base_uri}/v1/search?q=#{keyword}"  
-    end
-    
-    def tags_v1_uri
-      "#{base_uri}/v1/repositories/#{docker_uri.repository}/tags"
-    end
-    
-    def tags_v2_uri
-      "#{base_uri}/v2/#{docker_uri.repository}/tags/list"  
-    end
-    
-    def hash_v2_uri(tag)
-      "#{base_uri}/v2/#{docker_uri.repository}/manifests/#{tag}"
-    end
-    
-  end
-end

data/lib/tagfish/tags_logic.rb

@@ -1,52 +0,0 @@
-require 'json'
-require 'tagfish/tags'
-
-module Tagfish
-  class TagsLogic
-    def self.find_tags_by_repository(docker_api, tags_only=false)
-      if docker_api.api_version == 'v2'
-        tags_list = tags_v2(docker_api, tags_only)
-      else
-        tags_list = tags_v1(docker_api)
-      end
-      Tagfish::Tags.new(tags_list)
-    end
-
-    private
-
-    def self.tags_v1(docker_api)
-      tags_json = docker_api.tags_v1
-      tags_v1_api(tags_json)
-    end
-
-    def self.tags_v1_api(api_response_data)
-      case api_response_data
-      when Hash
-        api_response_data
-      when Array
-        api_response_data.reduce({}) do |images, tag|
-          images.merge({tag["name"] => tag["layer"]})
-        end
-      else
-        raise "unexpected type #{api_response_data.class}"
-      end
-    end
-
-    def self.tags_v2(docker_api, tags_only)
-      tags = docker_api.tags_v2["tags"]
-      if tags.nil?
-        abort("No Tags found for this repository")
-      end
-      
-      tags_with_hashes = tags.inject({}) do |dict, tag|
-        if tags_only
-          dict[tag] = "dummy_hash"
-        else
-          dict[tag] = docker_api.hash_v2(tag)["fsLayers"][0]["blobSum"]
-        end
-        dict
-      end
-    end
-    
-  end
-end