fpm-fry 0.2.2 → 0.4.6

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

data/lib/fpm/fry/docker_file.rb

@@ -1,7 +1,6 @@
 require 'fiber'
 require 'shellwords'
 require 'rubygems/package'
-require 'fpm/fry/os_db'
 require 'fpm/fry/source'
 require 'fpm/fry/joined_io'
 module FPM; module Fry
@@ -12,12 +11,13 @@ module FPM; module Fry
     class Source < Struct.new(:variables, :cache)
 
       def initialize(variables, cache = Source::Null::Cache)
-        variables = variables.dup
-        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
-          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
-        end
-        variables.freeze
+        variables = variables.dup.freeze
         super(variables, cache)
+        if cache.respond_to? :logger
+          @logger = cache.logger
+        else
+          @logger = Cabin::Channel.get
+        end
       end
 
       def dockerfile
@@ -26,8 +26,8 @@ module FPM; module Fry
 
         df << "RUN mkdir /tmp/build"
 
-        cache.file_map.each do |from, to|
-          df << "ADD #{map_from(from)} #{map_to(to)}"
+        file_map.each do |from, to|
+          df << "COPY #{map_from(from)} #{map_to(to)}"
         end
 
         df << ""
@@ -52,6 +52,33 @@ module FPM; module Fry
         return sio
       end
 
+    private
+
+      attr :logger
+
+      def file_map
+        prefix = ""
+        to = ""
+        if cache.respond_to? :prefix
+          prefix = cache.prefix
+        end
+        if cache.respond_to? :to
+          to = cache.to || ""
+        end
+        fm = cache.file_map
+        if fm.nil?
+          return { prefix => to }
+        end
+        if fm.size == 1
+          key, value = fm.first
+          key = key.gsub(%r!\A\./|/\z!,'')
+          if ["",".","./"].include?(value) && key == prefix
+            logger.hint("You can remove the file_map: #{fm.inspect} option on source. The given value is the default")
+          end
+        end
+        return fm
+      end
+
       def map_to(dir)
         if ['','.'].include? dir
           return '/tmp/build'
@@ -76,27 +103,34 @@ module FPM; module Fry
       private :options
 
       def initialize(base, variables, recipe, options = {})
-        variables = variables.dup
-        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
-          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
-        end
-        variables.freeze
+        variables = variables.dup.freeze
+        raise Fry::WithData('unknown flavour', 'flavour' => variables[:flavour]) unless ['debian','redhat'].include? variables[:flavour]
         @options = options.dup.freeze
         super(base, variables, recipe)
       end
 
       def dockerfile
-        df = []
-        df << "FROM #{base}"
-        df << "WORKDIR /tmp/build"
+        df = {
+          source: [],
+          dependencies: [],
+          build: []
+        }
+        df[:source] << "FROM #{base}"
+        workdir = '/tmp/build'
+        # TODO: get this from cache, not from the source itself
+        if recipe.source.respond_to? :to
+          to = recipe.source.to || ""
+          workdir = File.expand_path(to, workdir)
+        end
+        df[:source] << "WORKDIR #{workdir}"
 
         # need to add external sources before running any command
         recipe.build_mounts.each do |source, target|
-          df << "ADD #{source} /tmp/build/#{target}"
+          df[:dependencies] << "COPY #{source} ./#{target}"
         end
 
-        recipe.apt_setup.each do |step|
-          df << "RUN #{step}"
+        recipe.before_dependencies_steps.each do |step|
+          df[:dependencies] << "RUN #{step.to_s}"
         end
 
         if build_dependencies.any?
@@ -106,22 +140,22 @@ module FPM; module Fry
             if options[:update]
               update = 'apt-get update && '
             end
-            df << "RUN #{update}apt-get install --yes #{Shellwords.join(build_dependencies)}"
+            df[:dependencies] << "RUN #{update}apt-get install --yes #{Shellwords.join(build_dependencies)}"
           when 'redhat'
-            df << "RUN yum -y install #{Shellwords.join(build_dependencies)}"
+            df[:dependencies] << "RUN yum -y install #{Shellwords.join(build_dependencies)}"
           else
             raise "Unknown flavour: #{variables[:flavour]}"
           end
         end
 
         recipe.before_build_steps.each do |step|
-          df << "RUN #{step.to_s}"
+          df[:build] << "RUN #{step.to_s}"
         end
 
-        df << "ADD .build.sh /tmp/build/"
-        df << "ENTRYPOINT /tmp/build/.build.sh"
-        df << ''
-        return df.join("\n")
+        df[:build] << "COPY .build.sh #{workdir}/"
+        df[:build] << "CMD #{workdir}/.build.sh"
+        recipe.apply_dockerfile_hooks(df)
+        return [*df[:source],*df[:dependencies],*df[:build],""].join("\n")
       end
 
       def build_sh

data/lib/fpm/fry/exec.rb

@@ -0,0 +1,76 @@
+require 'fpm/fry/with_data'
+require 'open3'
+module FPM
+  module Fry
+
+    module Exec
+
+      # Raised when running a command failed.
+      class Failed < StandardError
+        include WithData
+
+        # @return [String] contents of stderr
+        def stderr
+          data[:stderr]
+        end
+
+      end
+
+      class << self
+
+        # @!method [](*cmd, options = {}) Runs a command and returns its stdout as string. This method is preferred if the expected output is short.
+        # @param [Array<String>] cmd command to run
+        # @param [Hash] options
+        # @option options [Cabin::Channel] :logger
+        # @option options [String] :description human readable string to describe what the command is doing
+        # @option options [String] :stdin_data data to write to stding
+        # @option options [String] :chdir directory to change to
+        # @return [String] stdout
+        # @raise [FPM::Fry::Exec::Failed] when exitcode != 0
+        def [](*args)
+          cmd, options, description = extract_options_and_log(args)
+          stdout, stderr, status = Open3.capture3(*cmd, options)
+          if status.exitstatus != 0
+            raise Exec.const_get("ExitCode#{status.exitstatus}").new("#{description} failed", exitstatus: status.exitstatus, stderr: stderr, stdout: stdout, command: cmd)
+          end
+          return stdout
+        end
+
+        alias exec []
+
+        # @!method popen(*cmd, options = {}) Runs a command and returns its stdout as IO.
+        # @param [Array<String>] cmd command to run
+        # @param [Hash] options
+        # @option options [Cabin::Channel] :logger
+        # @option options [String] :description human readable string to describe what the command is doing
+        # @option options [String] :chdir directory to change to
+        # @return [IO] stdout
+        def popen(*args)
+          cmd, options, _description = extract_options_and_log(args)
+          return IO.popen(cmd, options)
+        end
+private
+        def extract_options_and_log(args)
+          options = args.last.kind_of?(Hash) ? args.pop.dup : {}
+          cmd = args
+          logger = options.delete(:logger)
+          description = options.delete(:description) || "Running #{cmd.join(' ')}"
+          if logger
+            logger.debug(description, command: args)
+          end
+          return cmd, options, description
+        end
+
+        def const_missing(name)
+          if name.to_s =~ /\AExitCode\d+\z/
+            klass = Class.new(Failed)
+            const_set(name, klass)
+            return klass
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/fpm/fry/inspector.rb

@@ -0,0 +1,70 @@
+module FPM::Fry
+  # An inspector allows a plugin to gather information about the image used to 
+  # build a package.
+  class Inspector
+
+    # Gets the file content at path.
+    #
+    # @param [String] path path to a file
+    # @raise [FPM::Fry::Client::FileNotFound] when the given path doesn't exist
+    # @raise [FPM::Fry::Client::NotAFile] when the given path is not a file
+    # @return [String] file content as string
+    def read_content(path)
+      return client.read_content(container, path)
+    end
+
+    # Gets whatever is at path. This once if path is a file. And all subfiles 
+    # if it's a directory. Usually read_content is better.
+    #
+    # @param [String] path path to a file
+    # @raise [FPM::Fry::Client::FileNotFound] when the given path doesn't exist
+    # @raise [FPM::Fry::Client::NotAFile] when the given path is not a file
+    # @yield [entry] tar file entry
+    # @yieldparam entry [Gem::Package::TarEntry]
+    def read(path, &block)
+      return client.read(container, path, &block)
+    end
+
+    # Determines the target of a link
+    #
+    # @param [String] path
+    # @raise [FPM::Fry::Client::FileNotFound] when the given path doesn't exist
+    # @return [String] target
+    # @return [nil] when file is not a link
+    def link_target(path)
+      return client.link_target(container, path)
+    end
+
+    # Checks if file exists at path
+    #
+    # @param [String] path
+    # @return [true] when path exists
+    # @return [false] otherwise
+    def exists?(path)
+      client.read(container,path) do
+        return true
+      end
+    rescue FPM::Fry::Client::FileNotFound
+      return false
+    end
+
+    def self.for_image(client, image)
+      container = client.create(image)
+      begin
+        yield new(client, container)
+      ensure
+        client.destroy(container)
+      end
+    end
+
+  private
+    def initialize(client, container)
+      @client, @container = client, container
+    end
+
+    attr :client
+    attr :container
+
+  end
+
+end