docker-cake 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c65060c27c01fce55231395ee5ad9200948a4be7
+  data.tar.gz: e9fc17acf691b35fbb212bb18fcd74b50d908308
+SHA512:
+  metadata.gz: da38d0dffb2c6e0eee7de50ec7f2f870e539878f67f65377da781011ad8df84985b96d6ec32e1029740e21dd2b1512985438be6fc8f9cc11b49e1c0986eee33b
+  data.tar.gz: 31857508135384c7a536cb8ce8dc304d26d943916741827d227f81adc0cfdb069703864725230dac4d0b2f33ae7c39752ec0e124834730d5121853850d36e200

data/.gitignore

@@ -0,0 +1,4 @@
+/target/
+**/*.rs.bk
+others
+*.gem

data/README.md

@@ -0,0 +1,29 @@
+# docker-cake
+
+Command line tool to compare image layers across tegs, build to optimize storage usage
+
+### Install:
+```sh
+gem install docker-cake
+```
+
+### Example:
+
+```
+docker-cake library/redmine
+
++-----------------+---------------------+------------+--------+--------------+--------------+------------+-----------+
+| Tag             | Date                | Size       | Layers | Reuse Layers | Extra Layers | Extra Size | Same as   |
++-----------------+---------------------+------------+--------+--------------+--------------+------------+-----------+
+| 3.4.1           | 2017-07-13 23:09:32 | 240.249 MB | 34     | 18           | 16           | 240.249 MB |           |
+| 3.4.1-passenger | 2017-07-13 23:09:58 | 258.997 MB | 38     | 36           | 2            | 18.748 MB  |           |
+| 3.4             | 2017-08-07 23:17:29 | 240.502 MB | 34     | 19           | 15           | 240.502 MB |           |
+| 3.4.2           | 2017-08-07 23:17:29 | 240.502 MB | 34     | 34           | 0            | 0 Bytes    | 3.4       |
+| 3               | 2017-08-07 23:17:29 | 240.502 MB | 34     | 34           | 0            | 0 Bytes    | 3.4       |
+| latest          | 2017-08-07 23:17:29 | 240.502 MB | 34     | 34           | 0            | 0 Bytes    | 3.4       |
+| passenger       | 2017-08-07 23:18:15 | 259.285 MB | 38     | 36           | 2            | 18.784 MB  |           |
+| 3.4-passenger   | 2017-08-07 23:18:15 | 259.285 MB | 38     | 38           | 0            | 0 Bytes    | passenger |
+| 3.4.2-passenger | 2017-08-07 23:18:15 | 259.285 MB | 38     | 38           | 0            | 0 Bytes    | passenger |
+| 3.3             | 2017-08-07 23:22:16 | 251.748 MB | 34     | 22           | 12           | 188.982 MB |           |
++-----------------+---------------------+------------+--------+--------------+--------------+------------+-----------+
+```

data/bin/docker-cake

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+$:.push(File.expand_path("../../lib", __FILE__))
+
+require 'docker_cake/cli'

data/docker-cake.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.specification_version = 3
+
+  gem.name = 'docker-cake'
+  gem.version = "0.1"
+  gem.authors = ["Pavel Evstigneev"]
+  gem.email = ["pavel.evst@gmail.com"]
+  gem.license = 'MIT'
+  gem.date = '2017-08-08'
+  gem.summary = "Command line program to inspect docker images size"
+  gem.homepage = 'https://github.com/paxa/docker-cake'
+
+  gem.files = `git ls-files`.split("\n")
+  gem.require_path = 'lib'
+  gem.executables   = ["docker-cake"]
+
+  gem.required_ruby_version = '>= 2.1'
+
+  gem.add_dependency 'terminal-table', ['>= 1.8.0', '<3']
+end

data/lib/docker-cake.rb

@@ -0,0 +1 @@
+require_relative 'docker_cake'

data/lib/docker_cake.rb

@@ -0,0 +1,133 @@
+require_relative 'docker_cake/registry_api_client'
+require 'time'
+require 'terminal-table'
+
+class DockerCake
+
+  attr_accessor :registry
+
+  def initialize(url: nil, user: nil, password: nil)
+    @registry ||= RegistryApiClient.new(user: user, password: password)
+  end
+
+  def repo_info(name, tag = 'latest')
+    manifest = registry.manifest_layers(name, tag)
+    puts print_manifest(manifest)
+  end
+
+  def compare_versions(repo_name, filter: /.+/, max: 10)
+    tags = registry.tags(repo_name, false)['tags']
+    tags.select! {|t| t =~ filter}
+
+    selected_tags = tags.last(max)
+
+    manifests = {}
+    procs = selected_tags.map do |tag|
+      lambda { manifests[tag] = registry.manifest_layers(repo_name, tag) }
+    end
+    registry.in_parallel(procs)
+    #selected_tags.each do |tag|
+    #  manifests[tag] = registry.manifest_layers(repo_name, tag)
+    #  #pp manifests[tag]
+    #end
+
+    manifests = manifests.sort_by do |tag, list|
+      list.map {|l| l['created'] }.max
+    end.to_h
+
+    images_map = {}
+    counted_layers = []
+    result = []
+
+    manifests.each do |tag, layers|
+      stats = {name: tag, size: 0, add_img: 0, reuse_img: 0, add_size: 0, layers: 0, date: Time.at(0).to_s}
+
+      map_key = manifests[tag].map {|l| l['blobSum']}.join(',')
+      if images_map[map_key]
+        stats[:same_as] = images_map[map_key]
+      end
+      images_map[map_key] ||= tag
+
+      manifests[tag].each do |layer|
+        stats[:size] += layer['size'] || 0
+        stats[:layers] += 1
+        stats[:date] = layer['created'] if layer['created'] > stats[:date]
+        if counted_layers.include?(layer['blobSum'])
+          stats[:reuse_img] += 1
+        else
+          stats[:add_img] += 1
+          stats[:add_size] += layer['size'] || 0
+        end
+
+        counted_layers << layer['blobSum']
+      end
+
+      #puts "#{tag} -> #{stats}"
+      result << stats
+    end
+
+    puts print_comparison(result)
+  end
+
+  def print_comparison(result)
+    rows = result.map do |stats|
+      [
+        stats[:name],
+        DateTime.parse(stats[:date]).strftime("%F %T"),
+        size_to_human(stats[:size]),
+        stats[:layers],
+        stats[:reuse_img],
+        stats[:add_img],
+        size_to_human(stats[:add_size]),
+        stats[:same_as]
+      ]
+    end
+
+    table = Terminal::Table.new(headings: ['Tag', 'Date', 'Size', 'Layers', 'Reuse Layers', 'Extra Layers', 'Extra Size', 'Same as'], rows: rows)
+  end
+
+  def print_manifest(manifest)
+    rows = manifest.map do |layer|
+      cmd = layer['container_config'] && layer['container_config']['Cmd'] || ['']
+      cmd = cmd.join(" ").gsub('\n', "\n").sub(/#{'/bin/sh -c'}\s+/, '')
+      if cmd.start_with?('#(nop)')
+        cmd.sub!(/#\(nop\)\s+/, '')
+      else
+        cmd = "RUN #{cmd}"
+      end
+
+      cmd.gsub!("\t", "    ")
+
+      shorter = []
+      cmd.lines.each do |line|
+        shorter.push(*line.scan(/.{1,90}/))
+      end
+
+      [
+        layer['id'][0...8],
+        DateTime.parse(layer['created']).strftime("%F %T"),
+        shorter.join("\n"),
+        size_to_human(layer['size'])
+      ]
+    end
+
+    rows << :separator << [nil, nil, 'TOTAL', size_to_human(manifest.sum {|layer| layer['size'].to_i })]
+
+    table = Terminal::Table.new(headings: ['ID', 'Date', 'CMD', 'Size'], rows: rows)
+  end
+
+  def size_to_human(size)
+    return '0' unless size
+
+    if size > 1_000_000_000
+      "#{(size / 1_000_000_000.0).round(3)} GB"
+    elsif size > 1_000_000
+      "#{(size / 1_000_000.0).round(3)} MB"
+    elsif size > 1_000
+      "#{(size / 1_000.0).round(3)} KB"
+    else
+      "#{size} Bytes"
+    end
+  end
+
+end

data/lib/docker_cake/cli.rb

@@ -0,0 +1,61 @@
+require 'optparse'
+require_relative '../docker_cake'
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: docker-cake [options] REPO"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-u", "--user [USER]", "Username, required for private repos") do |v|
+    options[:user] = v
+  end
+
+  opts.on("-p", "--password [PASSWORD]", "Password, required for private repos") do |v|
+    options[:password] = v
+  end
+
+  opts.on("-r", "--registry [REGISTRY URL]", "Docker registry URL, default is https://registry.hub.docker.com") do |v|
+    options[:url] = v
+  end
+
+  opts.on("-l", "--layers", "Print layers of image") do |v|
+    options[:layers] = v
+  end
+
+  opts.on("-n", "--max [NUM TAGS]", "Number of tags to analyse, default is 10") do |v|
+    options[:max] = v
+  end
+
+end
+
+parser.parse!
+
+if options[:verbose]
+  ENV['DEBUG'] = '1'
+  p options
+end
+
+repo = ARGV.first
+tag = ARGV[1]
+
+if !repo || repo == ''
+  puts "Repository name is required"
+  puts "Example:"
+  puts "    docker-cake library/ruby"
+  puts "    docker-cake --help"
+  exit(1)
+end
+
+connect_options = {user: options[:user], password: options[:password]}
+connect_options[:url] = options[:url] if options[:url]
+
+if options[:layers]
+  DockerCake.new(connect_options).repo_info(repo, tag || 'latest')
+else
+  opts = {}
+  opts[:max] = options[:max].to_i if options[:max]
+  DockerCake.new(connect_options).compare_versions(repo, opts)
+end

data/lib/docker_cake/registry_api_client.rb

@@ -0,0 +1,459 @@
+require 'json'
+require 'uri'
+require 'socket'
+require 'net/http'
+
+class RegistryApiClient
+
+  class RegistryAuthenticationException < Exception
+  end
+
+  class RegistryAuthorizationException < Exception
+  end
+
+  class RegistryUnknownException < Exception
+  end
+
+  class RegistrySSLException < Exception
+  end
+  
+  class ReauthenticatedException < Exception
+  end
+  
+  class UnknownRegistryException < Exception
+  end
+
+  class InvalidMethod < Exception
+  end
+
+  class Waiter
+    def initialize
+      @queue = Queue.new
+    end
+
+    # Waiting for someone to call #notify
+    def wait
+      @queue.pop(false)
+    end
+
+    # Notify waiting side
+    def notify(data)
+      @queue.push(data)
+    end
+  end
+
+  # It's same as waiter but support multiple subscribers
+  class PubSub
+    def initialize
+      @waiters = []
+    end
+
+    def wait
+      waiter = Waiter.new
+      @waiters << waiter
+      waiter.wait
+    end
+
+    def notify(value)
+      while waiter = @waiters.shift
+        waiter.notify(value)
+      end
+    end
+  end
+
+  DEFAULT_REGISTRY = "https://registry.hub.docker.com"
+  DEFAULT_MANIFEST = "application/vnd.docker.distribution.manifest.v2+json"
+  FAT_MANIFEST =     "application/vnd.docker.distribution.manifest.list.v2+json"
+
+  # @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
+  def initialize(url: DEFAULT_REGISTRY, user: nil, password: nil)
+    @url = url
+    uri = URI.parse(url)
+    @base_uri = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+    @user = user
+    @password = password
+    @manifest_format = "application/vnd.docker.distribution.manifest.v2+json"
+    #@manifest_format = "application/vnd.docker.distribution.manifest.list.v2+json"
+    #@manifest_format = "application/vnd.docker.container.image.v1+json"
+    # make a ping connection
+    #ping
+  end
+
+  def http_get(url, manifest: nil, auth: nil, auth_header: nil)
+    http_req("get", url, manifest: manifest, auth: auth, auth_header: auth_header)
+  end
+
+  def http_delete(url)
+    http_req("delete", url)
+  end
+
+  def http_head(url)
+    http_req("head", url)
+  end
+
+  def ping
+    response = http_get('/v2/')
+  end
+
+  def search(query = '')
+    response = http_get "/v2/_catalog"
+    # parse the response
+    repos = JSON.parse(response)["repositories"]
+    if query.strip.length > 0
+      re = Regexp.new query
+      repos = repos.find_all {|e| re =~ e }
+    end
+    return repos
+  end
+
+  def tags(repo, withHashes = false)
+    response = http_get("/v2/#{repo}/tags/list")
+    # parse the response
+    resp = JSON.parse(response)
+    # do we include the hashes?
+    if withHashes then
+      useGet = false
+      resp["hashes"] = {}
+      resp["tags"].each {|tag|
+        if useGet then
+          head = http_get "/v2/#{repo}/manifests/#{tag}"
+        else
+          begin
+            head = http_head("/v2/#{repo}/manifests/#{tag}")
+          rescue InvalidMethod
+            # in case we are in a registry pre-2.3.0, which did not support manifest HEAD
+            useGet = true
+            head = http_get("/v2/#{repo}/manifests/#{tag}")
+          end
+        end
+        resp["hashes"][tag] = head.headers[:docker_content_digest]
+      }
+    end
+
+    return resp
+  end
+
+  # combines small output and fat output to get layer names and sizes
+  def manifest(repo, tag, manifest: nil)
+    if @url == DEFAULT_REGISTRY
+      auth_header = %{Bearer realm="https://auth.docker.io/token",service="registry.docker.io",scope="repository:#{repo}:pull"}
+    end
+    JSON.parse(http_get("/v2/#{repo}/manifests/#{tag}", manifest: manifest, auth: :bearer, auth_header: auth_header))
+  end
+
+  def manifest_layers(repo, tag)
+    basic_response = nil
+    fat_response = nil
+
+    resp = in_parallel(
+      basic: lambda { manifest(repo, tag) },
+      fat:   lambda { manifest(repo, tag, manifest: FAT_MANIFEST) }
+    )
+
+    unless resp[:basic]['layers']
+      puts "Strange response"
+      p resp[:basic]
+    end
+
+    basic = resp[:basic]['layers'] || []
+    fat_response = resp[:fat]
+
+    result = []
+
+    fat_response['history'].each_with_index do |info, index|
+      result[index] = JSON.parse(info['v1Compatibility'])
+      result[index]['blobSum'] = fat_response['fsLayers'][index]['blobSum']
+      result[index]['size'] = basic.detect do |layer|
+        layer['digest'] == result[index]['blobSum']
+      end
+      result[index]['size'] = result[index]['size']['size'] if result[index]['size']
+    end
+
+    # require 'irb'
+    # binding.irb
+
+    result.reverse
+  end
+
+  def in_parallel(procs = {})
+    threads = []
+    result = {}
+    errors = []
+    procs.each do |key, fun|
+      # handle array
+      if fun == nil && key.is_a?(Proc)
+        fun = key
+        key = result.size
+      end
+      result[key] = nil
+      threads << Thread.new do
+        begin
+          result[key] = fun.call
+        rescue => error
+          puts "#{error.class}: #{error.message}"
+          puts error.backtrace
+          errors << error
+        end
+      end
+    end
+
+    threads.map(&:join)
+
+    if errors.size > 0
+      raise errors.first
+    end
+
+    result
+  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 = http_head("/v2/#{repo}/blobs/#{blobSum}")
+    Integer(response.headers[:content_length], 10)
+  end
+
+  def manifest_sum(manifest)
+    size = 0
+    manifest["layers"].each do |layer|
+      size += layer["size"]
+    end
+    size
+  end
+
+  private
+    def http_req(type, url, stream: nil, manifest: nil, auth: nil, auth_header: nil)
+      begin
+        if auth == :bearer && auth_header
+          return do_bearer_req(type, url, auth_header, stream: stream, manifest: manifest)
+        else
+          return req_no_auth(type, url, stream: stream, manifest: manifest)
+        end
+      rescue SocketError => e
+        p e
+        raise RegistryUnknownException
+      rescue HTTP::Unauthorized => e
+        header = e.response.headers[:www_authenticate]
+        method = header.downcase.split(' ')[0]
+        case method
+        when 'basic'
+          response = do_basic_req(type, url, stream: stream, manifest: manifest)
+        when 'bearer'
+          response = do_bearer_req(type, url, header, stream: stream, manifest: manifest)
+        else
+          raise RegistryUnknownException
+        end
+      end
+      return response
+    end
+
+    def req_no_auth(type, url, stream: nil, manifest: nil)
+      block = stream.nil? ? nil : proc do |response|
+        response.read_body do |chunk|
+          stream.write chunk
+        end
+      end
+      response = HTTP.execute(
+        method: type,
+        url: @base_uri + url,
+        headers: {Accept: manifest || @manifest_format},
+        block_response: block
+      )
+    end
+
+    def do_basic_req(type, url, stream: nil, manifest: nil)
+      begin
+        block = stream.nil? ? nil : proc { |response|
+          response.read_body do |chunk|
+            stream.write chunk
+          end
+        }
+        response = HTTP.execute(
+          method: type,
+          url: @base_uri + url,
+          user: @user,
+          password: @password,
+          headers: {Accept: manifest || @manifest_format},
+          block_response: block
+        )
+      rescue SocketError
+        raise RegistryUnknownException
+      rescue HTTP::Unauthorized
+        raise RegistryAuthenticationException
+      rescue MethodNotAllowed
+        raise InvalidMethod
+      end
+      return response
+    end
+
+    def do_bearer_req(type, url, header, stream: false, manifest: nil)
+      token = authenticate_bearer(header)
+      begin
+        block = stream.nil? ? nil : proc { |response|
+          response.read_body do |chunk|
+            stream.write chunk
+          end
+        }
+        response = HTTP.execute(
+          method: type,
+          url: @base_uri + url,
+          headers: {Authorization: 'Bearer ' + token, Accept: manifest || @manifest_format},
+          block_response: block
+        )
+      rescue SocketError
+        raise RegistryUnknownException
+      rescue HTTP::Unauthorized
+        raise RegistryAuthenticationException
+      rescue MethodNotAllowed
+        raise InvalidMethod
+      end
+
+      return response
+    end
+
+    AUTH_CACHE = {}
+
+    def authenticate_bearer(header)
+      # get the parts we need
+      target = split_auth_header(header)
+      scope = target[:params][:scope]
+
+      if AUTH_CACHE[scope].is_a?(String)
+        return AUTH_CACHE[scope]
+      elsif AUTH_CACHE[scope].is_a?(PubSub)
+        return AUTH_CACHE[scope].wait
+      else
+        AUTH_CACHE[scope] = PubSub.new
+      end
+
+      # did we have a username and password?
+      if defined? @user and @user.to_s.strip.length != 0
+        target[:params][:account] = @user
+      end
+      # authenticate against the realm
+      uri = URI.parse(target[:realm])
+      begin
+        response = HTTP.execute(
+          method: :get,
+          url: uri.to_s,
+          query: target[:params],
+          user: @user,
+          password: @password
+        )
+      rescue HTTP::Unauthorized
+        # bad authentication
+        raise RegistryAuthenticationException
+      end
+      # now save the web token
+      token = JSON.parse(response)["token"]
+      AUTH_CACHE[scope].notify(token)
+      AUTH_CACHE[scope] = token
+      return token
+    end
+
+    def split_auth_header(header = '')
+      h = Hash.new
+      h = {params: {}}
+      header.split(/[\s,]+/).each {|entry|
+        p = entry.split('=')
+        case p[0]
+        when 'Bearer'
+        when 'realm'
+          h[:realm] = p[1].gsub(/(^\"|\"$)/,'')
+        else
+          h[:params][p[0]] = p[1].gsub(/(^\"|\"$)/,'')
+        end
+      }
+      h
+    end
+
+  module HTTP
+    extend self
+
+    class Unauthorized < Exception
+      attr_accessor :response
+      def initialize(message, response)
+        super(message)
+        @response = response
+      end
+    end
+
+    class MethodNotAllowed < Exception
+      attr_accessor :response
+      def initialize(message, response)
+        super(message)
+        @response = response
+      end
+    end
+
+    def execute(method:, url:, headers: {}, user: nil, password: nil, block_response: nil, body: nil, query: nil)
+      if query
+        uri = URI.parse(url)
+        url += (uri.query ? "&" : "?") + URI.encode_www_form(query)
+      end
+      uri = URI.parse(url)
+      response = nil
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http_klass = case method.to_sym
+          when :get    then Net::HTTP::Get
+          when :post   then Net::HTTP::Post
+          when :put    then Net::HTTP::Put
+          when :patch  then Net::HTTP::Patch
+          when :head   then Net::HTTP::Head
+          when :delete then Net::HTTP::Delete
+          when :move   then Net::HTTP::Move
+          when :copy   then Net::HTTP::Copy
+          else Net::HTTP::Post
+        end
+
+        request = http_klass.new(uri)
+        headers.each do |key, value|
+          request[key.to_s] = value
+        end
+
+        if body
+          request.body = body
+        end
+
+        if user != nil || password != nil
+          request.basic_auth(user, password)
+        end
+
+        puts "HTTP req #{method} #{url} #{headers}" if ENV['DEBUG']
+
+        http_resp = http.request(request)
+
+        puts "-> HTTP status: #{http_resp.code} size: #{http_resp.body.size}" if ENV['DEBUG']
+
+        response = Response.new(http_resp)
+
+        if http_resp.code.to_s == "401"
+          raise Unauthorized.new(http_resp.body, response)
+        end
+
+        if http_resp.code.to_s == "405"
+          raise MethodNotAllowed.new(http_resp.body, response)
+        end
+
+        return response
+      end
+    end
+
+    class Response < String
+      attr_accessor :headers
+
+      def initialize(http_response)
+        @http_response = http_response
+        @headers = {}
+        @http_response.to_hash.each do |key, value|
+          @headers[key.gsub('-', '_').to_sym] = value.last
+        end
+        super(http_response.body)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: docker-cake
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Pavel Evstigneev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 
+email:
+- pavel.evst@gmail.com
+executables:
+- docker-cake
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- bin/docker-cake
+- docker-cake.gemspec
+- lib/docker-cake.rb
+- lib/docker_cake.rb
+- lib/docker_cake/cli.rb
+- lib/docker_cake/registry_api_client.rb
+homepage: https://github.com/paxa/docker-cake
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 3
+summary: Command line program to inspect docker images size
+test_files: []