fpm-fry 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30f03302993885946a899feba8c6f6a63f9cc46a
-  data.tar.gz: 6cf9d78c60aca34c1c8feab1b58ddd9234fe28b9
+  metadata.gz: de6bc3a9f29acd7c147a4016c4906fd0a35c6481
+  data.tar.gz: afece6f8aea44147df5e357015115f9c74614071
 SHA512:
-  metadata.gz: d832baed68a8f809a009bcdb7d8addb4847393475f1bc4ae12d5a562210ddbc3506f1e6e310d4798b68197b75a649152ea05449ce2ef18ad4e34f321094efb9d
-  data.tar.gz: ca77a79b3aad02271b8dd9cf4e9c31d556c7125065ea7b1df0917d3677a433b64b8a32a7bd90e3a527a5f7016533dcd766393472cf5c30cb8b4d99e16fb6107f
+  metadata.gz: 3fea3ee2114b957eca0789a06faab401d88ff9269bf95ffab42ce79f367716d4b962b964e44aa03ef58087c50c1df5c904195f1ac44cde705bc17c5c0a9d2e63
+  data.tar.gz: ccee1a75f08a186ff5a44e673d297ca41e2ce6faee2b4df57715542eafbf8640b605e0f7c619958f8b4a7967abd76b8192eadd6e72d5ffcecb07ab1ca27c9949

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/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
@@ -72,12 +86,17 @@ class FPM::Fry::Client
     return to_enum(:read, name, resource) unless block_given?
     res = agent.get(
       path: url('containers',name,'archive'),
-      query: URI.encode_www_form('path' => resource),
+      query: {'path' => resource},
       headers: { 'Content-Type' => 'application/json' },
       expects: [200,404,500]
     )
-    if res.status == 500
-      raise FileNotFound, "File #{resource.inspect} not found: #{res.body}"
+    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 )
@@ -86,6 +105,41 @@ class FPM::Fry::Client
     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 +159,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

@@ -23,6 +23,7 @@ module FPM; module Fry
     def initialize(invocation_path, ctx = {}, parent_attribute_values = {})
       super
       @ui = ctx.fetch(:ui){ UI.new }
+      @client = ctx[:client]
     end
 
     def parse(attrs)
@@ -45,48 +46,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
@@ -168,22 +149,12 @@ 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|
+          Inspector.for_image(client, image) do |inspector|
+            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')
-              return true
+              break
             end
-          ensure
-            client.delete(path: client.url('containers',container))
           end
           return true
         when 'always'
@@ -242,7 +213,7 @@ module FPM; module Fry
         return yield container
       ensure
         unless keep?
-          client.delete(path: client.url('containers',container))
+          client.destroy(container)
         end
       end
     end
@@ -359,11 +330,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
 

data/lib/fpm/fry/detector.rb

@@ -1,117 +1,62 @@
-require 'fpm/fry/client'
+require 'fpm/fry/detector'
 module FPM; module Fry
 
   module Detector
-
-    class String < Struct.new(:value)
-      attr :distribution
-      attr :version
-
-      def detect!
-        @distribution, @version = value.split('-',2)
-        return true
+    # Detects a set of basic properties about an image.
+    #
+    # @param [Inspector] inspector
+    # @return [Hash<Symbol, String>]
+    def self.detect(inspector)
+      found = {}
+      if inspector.exists? '/usr/bin/apt-get'
+        found[:flavour] = 'debian'
+      elsif inspector.exists? '/bin/rpm'
+        found[:flavour] = 'redhat'
       end
-
-    end
-
-    class Container < Struct.new(:client,:container)
-      attr :distribution
-      attr :version
-
-      def detect!
-        begin
-          client.read(container,'/etc/lsb-release') do |file|
-            file.read.each_line do |line|
-              case(line)
-              when /\ADISTRIB_ID=/ then
-                @distribution = $'.strip.downcase
-              when /\ADISTRIB_RELEASE=/ then
-                @version = $'.strip
-              end
-            end
-          end
-          return !!(@distribution and @version)
-        rescue Client::FileNotFound
-        end
-        begin
-          client.read(container,'/etc/debian_version') do |file|
-            content = file.read
-            if /\A\d+(?:\.\d+)+\Z/ =~ content
-              @distribution = 'debian'
-              @version = content.strip
-            end
-          end
-          return !!(@distribution and @version)
-        rescue Client::FileNotFound
-        end
-        begin
-          client.read(container,'/etc/redhat-release') do |file|
-            if file.header.typeflag == "2" # centos links this file
-              client.read(container,File.absolute_path(file.header.linkname,'/etc')) do |file|
-                detect_redhat_release(file)
-              end
-            else
-              detect_redhat_release(file)
-            end
+      begin
+        inspector.read_content('/etc/lsb-release').each_line do |line|
+          case(line)
+          when /\ADISTRIB_ID=/ then
+            found[:distribution] = $'.strip.downcase
+          when /\ADISTRIB_RELEASE=/ then
+            found[:release] = $'.strip
+          when /\ADISTRIB_CODENAME=/ then
+            found[:codename] = $'.strip
           end
-          return !!(@distribution and @version)
-        rescue Client::FileNotFound
         end
-        return false
+      rescue Client::FileNotFound
       end
 
-    private
-      def detect_redhat_release(file)
-        file.read.each_line do |line|
+      begin
+        inspector.read_content('/etc/os-release').each_line do |line|
           case(line)
-          when /\A(\w+) release ([\d\.]+)/ then
-            @distribution = $1.strip.downcase
-            @version = $2.strip
+          when /\AVERSION=\"(\w+) \((\w+)\)\"/ then
+            found[:release] ||= $1
+            found[:codename] ||= $2
           end
         end
+      rescue Client::FileNotFound
       end
-    end
-
-    class Image < Struct.new(:client,:image,:factory)
-
-      class ImageNotFound < StandardError
-      end
-
-      attr :distribution
-      attr :version
-
-      def initialize(client, image, factory = Container)
-        super
-      end
-
-      def detect!
-        body = JSON.generate({"Image" => image, "Cmd" => "exit 0"})
-        begin
-          res = client.post( path: client.url('containers','create'),
-                             headers: {'Content-Type' => 'application/json'},
-                             body: body,
-                             expects: [201]
-                           )
-        rescue Excon::Errors::NotFound
-          raise ImageNotFound, "Image #{image.inspect} not found. Did you do a `docker pull #{image}` before?"
+      begin
+        content = inspector.read_content('/etc/debian_version')
+        if /\A\d+(?:\.\d+)+\Z/ =~ content
+          found[:distribution] ||= 'debian'
+          found[:release] = content.strip
         end
-        body = JSON.parse(res.body)
-        container = body.fetch('Id')
-        begin
-          d = factory.new(client,container)
-          if d.detect!
-            @distribution = d.distribution
-            @version = d.version
-            return true
-          else
-            return false
+      rescue Client::FileNotFound
+      end
+      begin
+        content = inspector.read_content('/etc/redhat-release')
+        content.each_line do |line|
+          case(line)
+          when /\A(\w+)(?: Linux)? release ([\d\.]+)/ then
+            found[:distribution] ||= $1.strip.downcase
+            found[:release] = $2.strip
           end
-        ensure
-          client.delete(path: client.url('containers',container))
         end
+      rescue Client::FileNotFound
       end
+      return found
     end
-
-
   end
 end ; end