fpm-fry 0.2.2 → 0.3.0

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,11 +11,7 @@ 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)
       end
 
@@ -76,11 +71,8 @@ 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

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

data/lib/fpm/fry/joined_io.rb

@@ -11,7 +11,7 @@ module FPM; module Fry
     end
 
     # Reads length bytes or all if length is nil.
-    # @param [Numeric, nil] length
+    # @param [Numeric, nil] len
     # @return [String] resulting bytes
     def read( len = nil )
       buf = []

data/lib/fpm/fry/plugin/edit_staging.rb

@@ -4,7 +4,7 @@ require 'fileutils'
 # A plugin to edit the final build results.
 # @example Add a file
 #   plugin 'edit_staging' do
-#     add_file '/a_file'
+#     add_file '/a_file', 'some content'
 #   end
 module FPM::Fry::Plugin::EditStaging
 

data/lib/fpm/fry/plugin/init.rb

@@ -1,53 +1,82 @@
 require 'fpm/fry/plugin'
+# A plugin that detects the init system of a docker image.
+#
+# This plugin is a low-level plugin and is used by other plugins such as "service".
+#
+# @example in a recipe when using the image "ubuntu:16.04"
+#   plugin 'init'
+#   init.systemd? #=> true
+#   init.sysv? #=> false
 module FPM::Fry::Plugin::Init
 
-  def self.detect_init(variables)
-    if variables[:init]
-      return variables[:init]
-    end
-    d = variables[:distribution]
-    v = variables[:distribution_version].split('.').map(&:to_i)
-    case(d)
-    when 'debian'
-      if v[0] < 8
-        return 'sysv'
-      else
-        return 'systemd'
-      end
-    when 'ubuntu'
-      if v[0] <= 14 && v[1] < 10
-        return 'upstart'
-      else
-        return 'systemd'
-      end
-    when 'centos','redhat'
-      if v[0] <= 5
-        return 'sysv'
-      elsif v[0] == 6
-        return 'upstart'
-      else
-        return 'systemd'
-      end
-    else
-      raise "Unknown init system for #{d} #{v.join '.'}"
+  # Contains information about the init system in use.
+  class System
+    # @return [Hash<Symbol,Object>] features of the init system
+    attr :with
+
+    def with?(feature)
+      !!with[feature]
+    end
+    def sysv?
+      name == :sysv
+    end
+    def upstart?
+      name == :upstart
+    end
+    def systemd?
+      name == :systemd
+    end
+  private
+    attr :name
+    def initialize(name, with)
+      @name, @with = name, with
     end
   end
 
-  def init(*inits)
-    inits = inits.flatten.map(&:to_s)
-    actual = FPM::Fry::Plugin::Init.detect_init(variables)
-    if inits.none?
-      return actual
-    elsif inits.include? actual
-      if block_given?
-        yield
-      else
-        return true
-      end
-    else
-      return false
+  # @return [System] initsystem in use
+  def init
+    return @init
+  end
+
+private
+  def self.detect(inspector)
+    if inspector.link_target('/sbin/init') == '/lib/systemd/systemd'
+      return System.new(:systemd, {})
+    end
+    if inspector.exists?('/etc/init')
+      return detect_upstart(inspector)
+    end
+    if inspector.exists?('/etc/init.d')
+      return detect_sysv(inspector)
     end
+    return nil
   end
 
+  def self.detect_upstart(inspector)
+    features = {
+      sysvcompat: inspector.exists?('/lib/init/upstart-job') ? '/lib/init/upstart-job' : false
+    }
+    return System.new(:upstart,features)
+  end
+
+  def self.detect_sysv(inspector)
+    features = {
+      chkconfig: inspector.exists?('/sbin/chkconfig'),
+      'update-rc.d': inspector.exists?('/usr/sbin/update-rc.d'),
+      'invoke-rc.d': inspector.exists?('/usr/sbin/invoke-rc.d')
+    }
+    return System.new(:sysv,features)
+  end
+
+  def self.extended(base)
+    base.instance_eval do
+      @init ||= FPM::Fry::Plugin::Init.detect(inspector)
+    end
+  end
+
+  def self.apply(builder)
+    builder.extend(self)
+    return builder.init
+  end
 
 end

data/lib/fpm/fry/plugin/service.rb

@@ -24,11 +24,12 @@ module FPM::Fry::Plugin ; module Service
 
   class DSL
 
+    # @return [Hash<String,Tuple<Numeric,Numeric>]
     attr :limits
 
-    def initialize(*_)
-      super
-      @name = nil
+    # @api private
+    def initialize(name)
+      @name = name
       @command = []
       @limits = {}
       @user = nil
@@ -36,20 +37,35 @@ module FPM::Fry::Plugin ; module Service
       @chdir = nil
     end
 
-    def name( n = nil )
-      if n
-        @name = n
+    # @overload name
+    #   @return [String] this service's name
+    # @overload name( name )
+    #   @param  [String] name new name for this service
+    #   @return [String] this service's name
+    def name( name = nil )
+      if name
+        @name = name
       end
       return @name
     end
 
-    def group( n = nil )
-      if n
-        @group = n
+    # @overload group
+    #   @return [String] the linux user group this service should run as
+    # @overload group( name )
+    #   @param  [String] name new linux user group this service should run as
+    #   @return [String] the linux user group this service should run as
+    def group( group = nil )
+      if group
+        @group = group
       end
       return @group
     end
 
+    # @overload user
+    #   @return [String] the linux user this service should run as
+    # @overload user( name )
+    #   @param  [String] name new linx user this service should run as
+    #   @return [String] the linux user this service should run as
     def user( n = nil )
       if n
         @user = n
@@ -57,13 +73,39 @@ module FPM::Fry::Plugin ; module Service
       return @user
     end
 
+    # Sets a limit for this service. Valid limits are:
+    #  
+    #   - core
+    #   - cpu
+    #   - data
+    #   - fsize
+    #   - memlock
+    #   - msgqueue
+    #   - nice
+    #   - nofile
+    #   - nproc
+    #   - rss
+    #   - rtprio
+    #   - sigpending
+    #   - stack
+    # 
+    # @see http://linux.die.net/man/5/limits.conf Limits.conf manpage for limits and their meanings.
+    # @param [String] name see above list for valid limits
+    # @param [Numeric,"unlimited"] soft soft limit
+    # @param [Numeric,"unlimited"] hard hard limit
     def limit( name, soft, hard = soft )
       unless LIMITS.include? name
         raise ArgumentError, "Unknown limit #{name.inspect}. Known limits are: #{LIMITS.inspect}"
       end
       @limits[name] = [soft,hard]
+      return nil
     end
 
+    # @overload chdir
+    #   @return [String,nil] working directory of the service
+    # @overload chdir( dir )
+    #   @param  [String] dir new working directory of the service
+    #   @return [String] working directory of the service
     def chdir( dir = nil )
       if dir
         @chdir = dir
@@ -80,76 +122,93 @@ module FPM::Fry::Plugin ; module Service
 
     # @api private
     def add!(builder)
-      name = self.name || builder.name || raise
-      init = Init.detect_init(builder.variables)
+      init = builder.plugin('init')
+      if init.systemd?
+        add_systemd!(builder)
+      elsif init.upstart?
+        add_upstart!(builder)
+      elsif init.sysv?
+        add_sysv!(builder)
+      end
+    end
+  private
+    def add_upstart!(builder)
+      init = builder.plugin('init')
       edit = builder.plugin('edit_staging')
       env = Environment.new(name, command, "", @limits, @user, @group, @chdir)
-      case(init)
-      when 'upstart' then
-        edit.add_file "/etc/init/#{name}.conf",StringIO.new( env.render('upstart.erb') )
-        edit.ln_s '/lib/init/upstart-job', "/etc/init.d/#{name}"
-        builder.plugin('script_helper') do |sh|
-          sh.after_install_or_upgrade(<<BASH)
+      edit.add_file "/etc/init/#{name}.conf",StringIO.new( env.render('upstart.erb') )
+      if init.with? :sysvcompat
+        edit.ln_s init.with[:sysvcompat], "/etc/init.d/#{name}"
+      end
+      builder.plugin('script_helper') do |sh|
+        sh.after_install_or_upgrade(<<BASH)
 if status #{Shellwords.shellescape name} 2>/dev/null | grep -q ' start/'; then
-  # It has to be stop+start because upstart doesn't pickup changes with restart.
-  if which invoke-rc.d >/dev/null 2>&1; then
-    invoke-rc.d #{Shellwords.shellescape name} stop
-  else
-    stop #{Shellwords.shellescape name}
-  fi
+# It has to be stop+start because upstart doesn't pickup changes with restart.
+if which invoke-rc.d >/dev/null 2>&1; then
+  invoke-rc.d #{Shellwords.shellescape name} stop
+else
+  stop #{Shellwords.shellescape name}
+fi
 fi
 if which invoke-rc.d >/dev/null 2>&1; then
-  invoke-rc.d #{Shellwords.shellescape name} start
+invoke-rc.d #{Shellwords.shellescape name} start
 else
-  start #{Shellwords.shellescape name}
+start #{Shellwords.shellescape name}
 fi
 BASH
-          sh.before_remove_entirely(<<BASH)
+        sh.before_remove_entirely(<<BASH)
 if status #{Shellwords.shellescape name} 2>/dev/null | grep -q ' start/'; then
-  stop #{Shellwords.shellescape name}
+stop #{Shellwords.shellescape name}
 fi
 BASH
-        end
-        builder.plugin('config', FPM::Fry::Plugin::Config::IMPLICIT => true) do |co|
-          co.include "etc/init/#{name}.conf"
-        end
-      when 'sysv' then
-        edit.add_file "/etc/init.d/#{name}",StringIO.new( env.render('sysv.erb') ), chmod: '750'
-        builder.plugin('script_helper') do |sh|
-          sh.after_install_or_upgrade(<<BASH)
+      end
+      builder.plugin('config', FPM::Fry::Plugin::Config::IMPLICIT => true) do |co|
+        co.include "etc/init/#{name}.conf"
+      end
+    end
+
+    def add_sysv!(builder)
+      edit = builder.plugin('edit_staging')
+      env = Environment.new(name, command, "", @limits, @user, @group, @chdir)
+      edit.add_file "/etc/init.d/#{name}",StringIO.new( env.render('sysv.erb') ), chmod: '750'
+      builder.plugin('script_helper') do |sh|
+        sh.after_install_or_upgrade(<<BASH)
 update-rc.d #{Shellwords.shellescape name} defaults
 /etc/init.d/#{Shellwords.shellescape name} restart
 BASH
-          sh.before_remove_entirely(<<BASH)
+        sh.before_remove_entirely(<<BASH)
 /etc/init.d/#{Shellwords.shellescape name} stop
 update-rc.d -f #{Shellwords.shellescape name} remove
 BASH
-        end
-        builder.plugin('config', FPM::Fry::Plugin::Config::IMPLICIT => true) do |co|
-          co.include "etc/init.d/#{name}"
-        end
-      when 'systemd' then
-        edit.add_file "/lib/systemd/system/#{name}.service", StringIO.new( env.render('systemd.erb') ), chmod: '644'
-        builder.plugin('script_helper') do |sh|
-          sh.after_install_or_upgrade(<<BASH)
+      end
+      builder.plugin('config', FPM::Fry::Plugin::Config::IMPLICIT => true) do |co|
+        co.include "etc/init.d/#{name}"
+      end
+    end
+
+    def add_systemd!(builder)
+      edit = builder.plugin('edit_staging')
+      env = Environment.new(name, command, "", @limits, @user, @group, @chdir)
+      edit.add_file "/lib/systemd/system/#{name}.service", StringIO.new( env.render('systemd.erb') ), chmod: '644'
+      builder.plugin('script_helper') do |sh|
+        sh.after_install_or_upgrade(<<BASH)
 systemctl preset #{Shellwords.shellescape name}.service
 if systemctl is-enabled --quiet #{Shellwords.shellescape name}.service ; then
-  systemctl --system daemon-reload
-  systemctl try-reload-or-restart #{Shellwords.shellescape name}.service
+systemctl --system daemon-reload
+systemctl restart #{Shellwords.shellescape name}.service
 fi
 BASH
-          sh.before_remove_entirely(<<BASH)
+        sh.before_remove_entirely(<<BASH)
 systemctl disable --now #{Shellwords.shellescape name}.service
 BASH
 
-        end
       end
     end
 
   end
 
   def self.apply(builder, &block)
-    d = DSL.new
+    d = DSL.new(builder.name)
     if !block
       raise ArgumentError, "service plugin requires a block"
     elsif block.arity == 1