fpm-fry 0.2.2 → 0.4.6

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

@@ -0,0 +1,75 @@
+require 'fpm/fry/plugin'
+require 'fpm/fry/chroot'
+
+# Automatically adds the appropriate maintainer scripts for every systemd unit.
+#
+# @note experimental
+#
+# @example in a recipe
+#   plugin 'systemd' # no options required, just install your units in /lib/systemd/system
+module FPM::Fry::Plugin::Systemd
+
+  # @api private
+  VALID_UNITS = /\A[a-z_0-9\-]+@?\.(service|socket|timer)\z/
+
+  # @api private
+  INSTANTIATED_UNITS = /\A[a-z_0-9\-]+@\.(service|socket|timer)\z/
+
+  # @api private
+  class Callback < Struct.new(:script_helper)
+
+    def call(_, package)
+      chroot = FPM::Fry::Chroot.new(package.staging_path)
+      files = chroot.entries('lib/systemd/system') - ['.','..']
+      valid, invalid = files.partition{|file| VALID_UNITS =~ file }
+      if invalid.any?
+        package.logger.warning("Found #{invalid.size} files in systemd unit path that are no systemd units", files: invalid)
+      end
+      units = valid.grep_v(INSTANTIATED_UNITS)
+      return if units.none?
+      package.logger.info("Added #{units.size} systemd units", units: valid)
+      script_helper.after_install_or_upgrade install(units)
+      script_helper.before_remove_entirely before_remove(units)
+      script_helper.after_remove_entirely after_remove(units)
+    end
+
+  private
+     def install(units)
+<<BASH
+if systemctl is-system-running ; then
+  systemctl preset #{units.join(' ')}
+  if systemctl is-enabled #{units.join(' ')} ; then
+    systemctl daemon-reload
+    systemctl restart #{units.join(' ')}
+  fi
+fi
+BASH
+     end
+
+     def before_remove(units)
+<<BASH
+if systemctl is-system-running ; then
+  systemctl disable --now #{units.join(' ')}
+fi
+BASH
+     end
+
+     def after_remove(units)
+<<BASH
+if systemctl is-system-running ; then
+  systemctl daemon-reload
+  systemctl reset-failed #{units.join(' ')}
+fi
+BASH
+     end
+
+  end
+
+  def self.apply(builder)
+    return unless builder.plugin('init').systemd?
+    builder.plugin('script_helper') do |sh|
+      builder.output_hooks << Callback.new(sh)
+    end
+  end
+
+end

data/lib/fpm/fry/recipe.rb

@@ -1,26 +1,28 @@
 require 'fpm/fry/source'
-require 'fpm/fry/source/package'
+require 'fpm/fry/source/archive'
 require 'fpm/fry/source/dir'
 require 'fpm/fry/source/patched'
 require 'fpm/fry/source/git'
 require 'fpm/fry/plugin'
-require 'fpm/fry/os_db'
+require 'fpm/fry/exec'
 require 'shellwords'
 require 'cabin'
-require 'open3'
 module FPM; module Fry
 
+  # A FPM::Fry::Recipe contains all information needed to build a package.
+  #
+  # It is usually created by {FPM::Fry::Recipe::Builder}.
   class Recipe
 
+    # A FPM::Fry::Recipe::Step is a named build step.
+    #
+    # @see FPM::Fry::Recipe#steps
     class Step < Struct.new(:name, :value)
       def to_s
         value.to_s
       end
     end
 
-    class DuplicateDependency < ArgumentError
-    end
-
     class PackageRecipe
       attr_accessor :name,
         :iteration,
@@ -60,7 +62,12 @@ module FPM; module Fry
 
       alias dependencies depends
 
+      # Applies settings to output package
+      # @param [FPM::Package] package
+      # @return [FPM::Package] package
+      # @api private
       def apply_output( package )
+        output_hooks.each{|h| h.call(self, package) }
         package.name = name
         package.version = version
         package.iteration = iteration
@@ -81,14 +88,16 @@ module FPM; module Fry
             end
           end
         end
-        output_hooks.each{|h| h.call(self, package) }
         return package
       end
 
       alias apply apply_output
 
+      # @api private
       SYNTAX_CHECK_SHELLS = ['/bin/sh','/bin/bash', '/bin/dash']
 
+      # Lints the settings for some common problems
+      # @return [Array<String>] problems
       def lint
         problems = []
         problems << "Name is empty." if name.to_s == ''
@@ -110,41 +119,58 @@ module FPM; module Fry
             problems << "#{type} script doesn't have a valid command in shebang"
           end
           if SYNTAX_CHECK_SHELLS.include? args[0]
-            sin, sout, serr, th = Open3.popen3(args[0],'-n')
-            sin.write(s)
-            sin.close
-            if th.value.exitstatus != 0
-              problems << "#{type} script is not valid #{args[0]} code: #{serr.read.chomp}"
+            begin
+              Exec::exec(args[0],'-n', stdin_data: s)
+            rescue Exec::Failed => e
+              problems << "#{type} script is not valid #{args[0]} code: #{e.stderr.chomp}"
             end
-            serr.close
-            sout.close
           end
         end
         return problems
       end
     end
 
-    attr_accessor :source,
-      :build_mounts,
-      :apt_setup,
-      :before_build_steps,
-      :steps,
-      :packages,
-      :build_depends,
-      :input_hooks
+    # @return [FPM::Fry::Source] the source used for building
+    attr_accessor :source
+
+    attr_accessor :build_mounts
+
+    # @return [Array<#to_s>] steps that will be carried out before dependencies are installed
+    attr_accessor :before_dependencies_steps
+
+    # @return [Array<#to_s>] steps that will be carried out before build
+    attr_accessor :before_build_steps
+
+    # @return [Array<#to_s>] steps that will be carried out during build
+    attr_accessor :steps
+
+    # @return [Array<FPM::Fry::PackageRecipe>] a list of packages that will be created
+    attr_accessor :packages
+
+    # @return [Hash<String,Hash>] build dependencies
+    attr_accessor :build_depends
+
+    # @return [Array<#call>] hooks that will be called on the input package
+    attr_accessor :input_hooks
+
+    # @return [Array<#call>] hooks that will be called when building the Dockerfile
+    attr_accessor :dockerfile_hooks
 
     def initialize
       @source = Source::Null
+      @before_dependencies_steps = []
       @before_build_steps = []
       @steps = []
       @packages = [PackageRecipe.new]
       @packages[0].files << '**'
       @build_depends = {}
       @input_hooks = []
+      @dockerfile_hooks = []
       @build_mounts = []
-      @apt_setup = []
     end
 
+    # Calculates all dependencies of this recipe
+    # @return [Hash<String,Hash>] the dependencies
     def depends
       depends = @packages.map(&:depends).inject(:merge)
       @packages.map(&:name).each do | n |
@@ -153,15 +179,30 @@ module FPM; module Fry
       return depends
     end
 
+    # Checks all packages for common errors
+    # @return [Array<String>] problems
     def lint
       packages.flat_map(&:lint)
     end
 
+    # Applies input settings to package
+    # @param [FPM::Package] package
+    # @return [FPM::Package]
     def apply_input( package )
       input_hooks.each{|h| h.call(self, package) }
       return package
     end
 
+    # Filters the dockerfile
+    # @api experimental
+    # @param [Hash] df
+    def apply_dockerfile_hooks( df )
+      dockerfile_hooks.each do |hook|
+        hook.call(self, df)
+      end
+      return nil
+    end
+
   end
 
 end ; end

data/lib/fpm/fry/recipe/builder.rb

@@ -1,21 +1,38 @@
 require 'fpm/fry/recipe'
 require 'fpm/fry/recipe/error'
 require 'forwardable'
+require 'fpm/fry/channel'
+
 module FPM::Fry
   class Recipe
 
     class NotFound < StandardError
     end
 
-    class PackageBuilder < Struct.new(:variables, :package_recipe)
+    class PackageBuilder
+
+      # @return [Hash<Symbol,Object>]
+      attr :variables
+
+      # @return [FPM::Fry::PackageRecipe]
+      attr :package_recipe
 
+      # @return [Cabin::Channel]
       attr :logger
 
-      def initialize( variables, recipe = PackageRecipe.new, options = {})
-        super(variables, recipe)
+      # @return [FPM::Fry::Inspector,nil]
+      attr :inspector
+
+      # @api private
+      def initialize( variables, package_recipe, options = {})
+        @variables = variables
+        @package_recipe = package_recipe
         @logger = options.fetch(:logger){ Cabin::Channel.get }
+        @inspector = options[:inspector]
       end
 
+      # Returns the package type ( e.g. "debian" or "redhat" ).
+      # @return [String]
       def flavour
         variables[:flavour]
       end
@@ -25,9 +42,13 @@ module FPM::Fry
       end
       alias platform distribution
 
-      def distribution_version
-        variables[:distribution_version]
+      # The release version of the distribution ( e.g. "12.04" or "6.0.7" )
+      # @return [String]
+      def release
+        variables[:release]
       end
+
+      alias distribution_version release
       alias platform_version distribution_version
 
       def codename
@@ -174,20 +195,20 @@ module FPM::Fry
 
     class Builder < PackageBuilder
 
+      # @return [FPM::Fry::Recipe]
       attr :recipe
 
-      def initialize( variables, recipe = Recipe.new, options = {})
+      # @param [Hash<Symbol,Object>] variables
+      # @param [Hash] options
+      # @option options [FPM::Fry::Recipe] :recipe (Recipe.new)
+      # @option options [Cabin::Channel] :logger (default cabin channel)
+      # @option options [FPM::Fry::Inspector] :inspector
+      def initialize( variables, options = {} )
+        recipe = options.fetch(:recipe){ Recipe.new }
         variables = variables.dup
-        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
-          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
-        end
-        if !variables[:codename] && OsDb[variables[:distribution]] && variables[:distribution_version]
-          codename = OsDb[variables[:distribution]][:codenames].find{|name,version| variables[:distribution_version].start_with? version }
-          variables[:codename] = codename[0] if codename
-        end
         variables.freeze
         @recipe = recipe
-        @before_build = false
+        @steps = :steps
         register_default_source_types!
         super(variables, recipe.packages[0], options)
       end
@@ -218,7 +239,9 @@ module FPM::Fry
       end
 
       def apt_setup(cmd)
-        recipe.apt_setup << cmd
+        before_dependencies do
+          bash cmd
+        end
       end
 
       def run(*args)
@@ -237,7 +260,10 @@ module FPM::Fry
           code = Recipe::Step.new(name, code)
         end
         # Don't do this at home
-        if @before_build
+        case(@steps)
+        when :before_dependencies
+          recipe.before_dependencies_steps << code
+        when :before_build
           recipe.before_build_steps << code
         else
           recipe.steps << code
@@ -245,10 +271,17 @@ module FPM::Fry
       end
 
       def before_build
-        @before_build = true
+        steps, @steps = @steps, :before_build
+        yield
+      ensure
+        @steps = steps
+      end
+
+      def before_dependencies
+        steps, @steps = @steps, :before_dependencies
         yield
       ensure
-        @before_build = false
+        @steps = steps
       end
 
       def build_depends( name , options = {} )
@@ -266,7 +299,7 @@ module FPM::Fry
         pr.version = package_recipe.version
         pr.iteration = package_recipe.iteration
         recipe.packages << pr
-        PackageBuilder.new(variables, pr).instance_eval(&block)
+        PackageBuilder.new(variables, pr, logger: logger, inspector: inspector).instance_eval(&block)
       end
 
     protected
@@ -289,7 +322,7 @@ module FPM::Fry
 
       def register_default_source_types!
         register_source_type Source::Git
-        register_source_type Source::Package
+        register_source_type Source::Archive
         register_source_type Source::Dir
       end
 

data/lib/fpm/fry/source.rb

@@ -1,34 +1,40 @@
+require 'fpm/fry/with_data'
 module FPM; module Fry ; module Source
 
+  # Raised when building a cache failed.
   class CacheFailed < StandardError
-
-    attr :data
-
-    def initialize(e, data = {})
-      if e.kind_of? Exception
-        @data = {reason: e}.merge data
-        super(e.message)
-      else
-        @data = data.dup
-        super(e.to_s)
-      end
-    end
+    include WithData
   end
 
+  # A special source that is empty.
   module Null
 
+    # A special cache that is empty.
     module Cache
+
+      # @return [IO] an empty tar
       def self.tar_io
         StringIO.new("\x00"*1024)
       end
+
+      # @return [Hash] an empty hash
       def self.file_map
         return {}
       end
+
+      # @return [String] 32 times zero
       def self.cachekey
         return '0' * 32
       end
+
+      # @return [String] common path prefix of all files that should be stripped
+      def self.prefix
+        return ""
+      end
     end
 
+    # @see FPM::Fry::Source::Null::Cache
+    # @return {FPM::Fry::Source::Null::Cache}
     def self.build_cache(*_)
       return Cache
     end
@@ -37,11 +43,34 @@ module FPM; module Fry ; module Source
 
   class << self
 
+    # @api private
     def guess_regex(rx, url)
       if m = rx.match(url.to_s)
         return m[0].size
       end
     end
 
+    # @api private
+    # @param dir [String] directory
+    # @return [String] prefix
+    def prefix(dir)
+      e = ::Dir.entries(dir)
+      if e.size != 3
+        return ""
+      end
+      other = (e - ['.','..']).first
+      path = File.join(dir, other)
+      if File.directory?( path )
+        pf = prefix(path)
+        if pf == ""
+          return other
+        else
+          return File.join(other, pf)
+        end
+      else
+        return ""
+      end
+    end
+
   end
 end ; end ; end