fpm-fry 0.2.2 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 30f03302993885946a899feba8c6f6a63f9cc46a
-  data.tar.gz: 6cf9d78c60aca34c1c8feab1b58ddd9234fe28b9
+SHA256:
+  metadata.gz: 34c54b8fc6358464ab255cd2e1bcd3fa53ee43f93aa57cef0e141cdfee2bc4de
+  data.tar.gz: b1f7127bc3961865d622c3a97178b2b37c2218ccf78ac3128807b70c0ce58fee
 SHA512:
-  metadata.gz: d832baed68a8f809a009bcdb7d8addb4847393475f1bc4ae12d5a562210ddbc3506f1e6e310d4798b68197b75a649152ea05449ce2ef18ad4e34f321094efb9d
-  data.tar.gz: ca77a79b3aad02271b8dd9cf4e9c31d556c7125065ea7b1df0917d3677a433b64b8a32a7bd90e3a527a5f7016533dcd766393472cf5c30cb8b4d99e16fb6107f
+  metadata.gz: 9300250c5c7fbd92391b8a4698e34aba6b88840ff7bb6abc5b41c817ac6651d2480088c63edd663d2356ad0ec66ff01bd7733e961ac47412fc9a6a0849e1f51f
+  data.tar.gz: 5db79a234b215966c5ef5eadcd60fe8216c7a14291ca3bec42ff585bc01f6417182d235baef7c6d8b636d38d4992a0abb2ccbcecc3ed4878c7cc4a02df74c7b0

data/lib/cabin/nice_output.rb

@@ -80,8 +80,23 @@ class Cabin::NiceOutput
     @io.flush
   end
 
+private
+
   def pp(hash)
-    hash.map{|k,v| '      '+k.to_s + ": " + v.inspect }.join("\n")
+    hash.map{|k,v| '      '+k.to_s + ": " + pp_value(v) }.join("\n")
+  end
+
+  def pp_value(value)
+    case(value)
+    when String
+      if value.include? "\n"
+        return "\n\t" + value.gsub("\n","\n\t")
+      else
+        return value
+      end
+    else
+      return value.inspect
+    end
   end
 
 end

data/lib/fpm/fry/block_enumerator.rb

@@ -1,10 +1,13 @@
 module FPM; module Fry
+  # Helper class that reads an IO in chunks.
+  #
+  # @api private
   class BlockEnumerator < Struct.new(:io, :blocksize)
     include Enumerable
 
-    # @param io [IO]
-    # @param blocksize [Numeric]
-    def initialize(_, blocksize = 128)
+    # @param [IO] io
+    # @param [Numeric] blocksize
+    def initialize(io, blocksize = 128)
       super
     end
 

data/lib/fpm/fry/build_output_parser.rb

@@ -10,12 +10,17 @@ module FPM; module Fry
     end
 
     def call(chunk, *_)
-      json = JSON.parse(chunk)
-      stream = json['stream']
-      if /\ASuccessfully built (\w+)\Z/.match(stream)
-        images << $1
+      # new docker for Mac results in data like this:
+      # "{'stream':' ---\\u003e 3bc51d6a4c46\\n'}\r\n{'stream':'Step 2 : WORKDIR /tmp/build\\n'}\r\n"
+      # this isn't valid JSON, of course, so we process each part individually
+      chunk.split("\r\n").each do |sub_chunk|
+        json = JSON.parse(sub_chunk)
+        stream = json['stream']
+        if /\ASuccessfully built (\w+)\Z/.match(stream)
+          images << $1
+        end
+        out << stream
       end
-      out << stream
     end
 
   end

data/lib/fpm/fry/channel.rb

@@ -1,17 +1,30 @@
 require 'cabin/channel'
 module FPM; module Fry
+  # A {Cabin::Channel} with two additional features:
+  #
+  # - There is a new log level 'hint' which can point users to improvements.
+  # - Logging an Exception that responds to #data will merge in the data from 
+  #   this exception. This is used together with {FPM::Fry::WithData}
+  #
+  # @api internal
   class Channel < Cabin::Channel
 
     module Hint
+      # Logs a message with level 'hint'
+      #
+      # @param [String] message
+      # @param [Hash] data
       def hint( message, data = {} )
         return unless hint?
         log(message, data.merge(level: :hint))
       end
 
+      # True if hints should be displayed
       def hint?
         !defined?(@hint) || @hint
       end
 
+      # Switched hints on or off
       def hint=( bool )
         @hint = !!bool
       end

data/lib/fpm/fry/chroot.rb

@@ -14,7 +14,7 @@ module FPM ; module Fry
 
     # Returns all directory entries like Dir.entries.
     # @param [String] path
-    # @result [Array<String>] entries
+    # @return [Array<String>] entries
     def entries(path)
       dir = rebase(path)
       return Dir.entries(dir)
@@ -34,7 +34,7 @@ module FPM ; module Fry
 
     # Yields all entries recursively like Find.find.
     # @param [String] path
-    # @yields entry
+    # @yield entry
     # @yieldparam [String] entry
     def find(path, &block)
       if stat(path).directory?

data/lib/fpm/fry/client.rb

@@ -1,15 +1,27 @@
+require 'cabin'
 require 'excon'
 require 'rubygems/package'
 require 'json'
 require 'fileutils'
 require 'forwardable'
 require 'fpm/fry/tar'
-
-module FPM; module Fry; end ; end
-
+require 'fpm/fry/with_data'
 class FPM::Fry::Client
 
+  # Raised when a file wasn't found inside a container
   class FileNotFound < StandardError
+    include FPM::Fry::WithData
+  end
+
+  # Raised when a container wasn't found.
+  class ContainerNotFound < StandardError
+    include FPM::Fry::WithData
+  end
+
+  # Raised when trying to read file that can't be read e.g. because it's a
+  # directory.
+  class NotAFile < StandardError
+    include FPM::Fry::WithData
   end
 
   extend Forwardable
@@ -41,6 +53,7 @@ class FPM::Fry::Client
     end
   end
 
+  # @return [String] docker server api version
   def server_version
     @server_version ||= begin
       res = agent.get(
@@ -51,6 +64,7 @@ class FPM::Fry::Client
     end
   end
 
+  # @return [String] docker cert path from environment
   def self.docker_cert_path
     ENV.fetch('DOCKER_CERT_PATH',File.join(Dir.home, '.docker'))
   end
@@ -70,22 +84,71 @@ class FPM::Fry::Client
 
   def read(name, resource)
     return to_enum(:read, name, resource) unless block_given?
-    res = agent.get(
-      path: url('containers',name,'archive'),
-      query: URI.encode_www_form('path' => resource),
-      headers: { 'Content-Type' => 'application/json' },
-      expects: [200,404,500]
-    )
-    if res.status == 500
-      raise FileNotFound, "File #{resource.inspect} not found: #{res.body}"
+    res = if (server_version['ApiVersion'] < "1.20")
+            agent.post(
+              path: url('containers', name, 'copy'),
+              headers: { 'Content-Type' => 'application/json' },
+              body: JSON.generate({'Resource' => resource}),
+              expects: [200,404,500]
+            )
+          else
+            agent.get(
+              path: url('containers', name, 'archive'),
+              headers: { 'Content-Type' => 'application/json' },
+              query: {:path => resource},
+              expects: [200,404,500]
+            )
+          end
+    if [404,500].include? res.status
+      body_message = Hash[JSON.load(res.body).map{|k,v| ["docker.#{k}",v] }] rescue {'docker.message' => res.body}
+      body_message['docker.container'] = name
+      if body_message['docker.message'] =~ /\ANo such container:/
+        raise ContainerNotFound.new("container not found", body_message)
+      end
+      raise FileNotFound.new("file not found", {'path' => resource}.merge(body_message))
     end
     sio = StringIO.new(res.body)
-    tar = ::Gem::Package::TarReader.new( sio )
+    tar = FPM::Fry::Tar::Reader.new( sio )
     tar.each do |entry|
       yield entry
     end
   end
 
+  # Gets the file contents while following symlinks
+  # @param [String] name the container name
+  # @param [String] resource the file name
+  # @return [String] content
+  # @raise [NotAFile] when the file has no readable content
+  # @raise [FileNotFound] when the file does not exist
+  # @api docker
+  def read_content(name, resource)
+    read(name, resource) do |file|
+      if file.header.typeflag == "2"
+        return read_content(name, File.absolute_path(file.header.linkname,File.dirname(resource)))
+      end
+      if file.header.typeflag != "0"
+        raise NotAFile.new("not a file", {'path' => resource})
+      end
+      return file.read
+    end
+  end
+
+  # Gets the target of a symlink
+  # @param [String] name the container name
+  # @param [String] resource the file name
+  # @return [String] target
+  # @return [nil] if resource is not a symlink
+  # @api docker
+  def link_target(name, resource)
+    read(name, resource) do |file|
+      if file.header.typeflag == "2"
+        return File.absolute_path(file.header.linkname,File.dirname(resource))
+      end
+      return nil
+    end
+    return nil
+  end
+
   def copy(name, resource, map, options = {})
     ex = FPM::Fry::Tar::Extractor.new(logger: @logger)
     base = File.dirname(resource)
@@ -105,6 +168,27 @@ class FPM::Fry::Client
     return JSON.parse(res.body)
   end
 
+  def pull(image)
+    agent.post(path: url('images','create'), query: {'fromImage' => image})
+  end
+
+  def create(image)
+    res = agent.post(
+      headers: { 'Content-Type' => 'application/json' },
+      path: url('containers','create'),
+      expects: [201],
+      body: JSON.generate('Image' => image)
+    )
+    return JSON.parse(res.body)['Id']
+  end
+
+  def destroy(container)
+    agent.delete(
+      path: url('containers',container),
+      expects: [204]
+    )
+  end
+
   def agent
     @agent ||= agent_for(docker_url, tls)
   end

data/lib/fpm/fry/command.rb

@@ -13,6 +13,9 @@ module FPM; module Fry
     option '--debug', :flag, 'Turns on debugging'
     option '--[no-]tls', :flag, 'Turns on tls ( default is false for schema unix, tcp and http and true for https )'
     option '--[no-]tlsverify', :flag, 'Turns off tls peer verification', default:true, environment_variable: 'DOCKER_TLS_VERIFY'
+    option ["-t", "--tmpdir"], "PATH", 'Write tmp data to PATH', default: '/tmp/fpm-fry', attribute_name: :dir do |s|
+      String(s)
+    end
 
     subcommand 'fpm', 'Works like fpm but with docker support', FPM::Command
 
@@ -22,7 +25,8 @@ module FPM; module Fry
 
     def initialize(invocation_path, ctx = {}, parent_attribute_values = {})
       super
-      @ui = ctx.fetch(:ui){ UI.new }
+      @ui = ctx.fetch(:ui){ UI.new(tmpdir: dir) }
+      @client = ctx[:client]
     end
 
     def parse(attrs)
@@ -45,48 +49,27 @@ module FPM; module Fry
 
     attr_writer :client
 
-    subcommand 'detect', 'Detects distribution from an image, a container or a given name' do
+    subcommand 'detect', 'Detects distribution from an image' do
 
-      option '--image', 'image', 'Docker image to detect'
-      option '--container', 'container', 'Docker container to detect'
-      option '--distribution', 'distribution', 'Distribution name to detect'
+      parameter 'image', 'Docker image to detect'
 
       attr :ui
       extend Forwardable
       def_delegators :ui, :logger
 
       def execute
-        require 'fpm/fry/os_db'
+        require 'fpm/fry/inspector'
         require 'fpm/fry/detector'
 
-        if image
-          d = Detector::Image.new(client, image)
-        elsif distribution
-          d = Detector::String.new(distribution)
-        elsif container
-          d = Detector::Container.new(client, container)
-        else
-          logger.error("Please supply either --image, --distribution or --container")
-          return 1
-        end
-
-        begin
-          if d.detect!
-            data = {distribution: d.distribution, version: d.version}
-            if i = OsDb[d.distribution]
-              data[:flavour] = i[:flavour]
-            else
-              data[:flavour] = "unknown"
-            end
-            logger.info("Detected distribution",data)
+        Inspector.for_image(client, image) do | inspector |
+          begin
+            data = Detector.detect(inspector)
+            logger.info("Detected the following parameters",data)
             return 0
-          else
-            logger.error("Detection failed")
-            return 2
+          rescue => e
+            logger.error(e)
+            return 1
           end
-        rescue => e
-          logger.error(e)
-          return 3
         end
       end
 

data/lib/fpm/fry/command/cook.rb

@@ -2,7 +2,6 @@ require 'fpm/fry/command'
 module FPM; module Fry
   class Command::Cook < Command
 
-    option '--distribution', 'distribution', 'Distribution like ubuntu-12.04'
     option '--keep', :flag, 'Keep the container after build'
     option '--overwrite', :flag, 'Overwrite package', default: true
 
@@ -22,40 +21,19 @@ module FPM; module Fry
       @tls = nil
       require 'digest'
       require 'fileutils'
+      require 'fpm/fry/with_data'
       require 'fpm/fry/recipe'
       require 'fpm/fry/recipe/builder'
       require 'fpm/fry/detector'
       require 'fpm/fry/docker_file'
       require 'fpm/fry/stream_parser'
-      require 'fpm/fry/os_db'
       require 'fpm/fry/block_enumerator'
       require 'fpm/fry/build_output_parser'
+      require 'fpm/fry/inspector'
+      require 'fpm/fry/plugin/config'
       super
     end
 
-    def detector
-      @detector || begin
-        if distribution
-          d = Detector::String.new(distribution)
-        else
-          d = Detector::Image.new(client, image)
-        end
-        self.detector=d
-      end
-    end
-
-    def detector=(d)
-      unless d.detect!
-        raise "Unable to detect distribution from given image"
-      end
-      @detector = d
-    end
-
-    def flavour
-      @flavour ||= OsDb.fetch(detector.distribution,{flavour: "unknown"})[:flavour]
-    end
-    attr_writer :flavour
-
     def output_class
       @output_class ||= begin
         logger.debug("Autodetecting package type",flavour: flavour)
@@ -75,19 +53,22 @@ module FPM; module Fry
 
     def builder
       @builder ||= begin
-        vars = {
-          distribution: detector.distribution,
-          distribution_version: detector.version,
-          flavour: flavour
-        }
-        logger.debug("Loading recipe",variables: vars, recipe: recipe)
-        b = Recipe::Builder.new(vars, Recipe.new, logger: ui.logger)
-        b.load_file( recipe )
+        b = nil
+        Inspector.for_image(client, image) do |inspector|
+          variables = Detector.detect(inspector)
+          logger.debug("Loading recipe",variables: variables, recipe: recipe)
+          b = Recipe::Builder.new(variables, logger: ui.logger, inspector: inspector)
+          b.load_file( recipe )
+        end
         b
       end
     end
     attr_writer :builder
 
+    def flavour
+      builder.variables[:flavour]
+    end
+
     def cache
       @cache ||= builder.recipe.source.build_cache(tmpdir)
     end
@@ -141,6 +122,9 @@ module FPM; module Fry
             path: client.url("build?rm=1&dockerfile=#{DockerFile::NAME}&t=#{cachetag}"),
             request_block: BlockEnumerator.new(df.tar_io)
           )
+        else
+          # Hack to trigger hints/warnings even when the cache is valid.
+          DockerFile::Source.new(builder.variables.merge(image: image_id),cache).send(:file_map)
         end
 
         df = DockerFile::Build.new(cachetag, builder.variables.dup,builder.recipe, update: update?)
@@ -168,22 +152,16 @@ module FPM; module Fry
       if flavour == 'debian'
         case(update)
         when 'auto'
-          body = JSON.generate({"Image" => image, "Cmd" => "exit 0"})
-          res = client.post( path: client.url('containers','create'),
-                             headers: {'Content-Type' => 'application/json'},
-                             body: body,
-                             expects: [201]
-                           )
-          body = JSON.parse(res.body)
-          container = body.fetch('Id')
-          begin
-            client.read( container, '/var/lib/apt/lists') do |file|
-              next if file.header.name == 'lists/'
-              logger.hint("/var/lib/apt/lists is not empty, you could try to speed up builds with --update=never", documentation: 'https://github.com/xing/fpm-fry/wiki/The-update-parameter')
-              return true
+          Inspector.for_image(client, image) do |inspector|
+            begin
+              inspector.read('/var/lib/apt/lists') do |file|
+                next if file.header.name == 'lists/'
+                logger.hint("/var/lib/apt/lists is not empty, you could try to speed up builds with --update=never", documentation: 'https://github.com/xing/fpm-fry/wiki/The-update-parameter')
+                break
+              end
+            rescue FPM::Fry::Client::FileNotFound
+              logger.hint("/var/lib/apt/lists does not exists, so we will autoupdate")
             end
-          ensure
-            client.delete(path: client.url('containers',container))
           end
           return true
         when 'always'
@@ -242,7 +220,7 @@ module FPM; module Fry
         return yield container
       ensure
         unless keep?
-          client.delete(path: client.url('containers',container))
+          client.destroy(container)
         end
       end
     end
@@ -304,6 +282,7 @@ module FPM; module Fry
 
       out_map.each do |output, package|
         package.apply_output(output)
+        adjust_package_settings(output)
         adjust_config_files(output)
       end
 
@@ -320,18 +299,24 @@ module FPM; module Fry
 
     end
 
+    def adjust_package_settings( output )
+      # FPM ignores the file permissions on rpm packages.
+      output.attributes[:rpm_use_file_permissions?] = true
+      output.attributes[:rpm_user] = 'root'
+      output.attributes[:rpm_group] = 'root'
+    end
 
     def adjust_config_files( output )
       # FPM flags all files in /etc as config files but only for debian :/.
-      # Actually this behavior makes sense to me for all packages because it's 
-      # the thing I usually want. By setting this attribute at least the 
+      # Actually this behavior makes sense to me for all packages because it's
+      # the thing I usually want. By setting this attribute at least the
       # misleading warning goes away.
       output.attributes[:deb_no_default_config_files?] = true
       output.attributes[:deb_auto_config_files?] = false
 
       return if output.attributes[:fry_config_explicitly_used]
 
-      # Now that we have disabled this for debian we have to reenable if it for 
+      # Now that we have disabled this for debian we have to reenable if it for
       # all.
       etc = File.expand_path('etc', output.staging_path)
       if File.exists?( etc )
@@ -359,11 +344,8 @@ module FPM; module Fry
     def execute
       # force some eager loading
       lint_recipe_file!
-      detector
-      flavour
-      output_class
-      lint_output_class!
       builder
+      lint_output_class!
       lint_recipe!
       cache