fpm-cookery 0.32.0 → 0.33.0

data/lib/fpm/cookery/book_hook.rb

@@ -10,6 +10,7 @@ module FPM
       module ClassMethods
         def inherited(klass)
           FPM::Cookery::Book.instance.add_recipe_class(klass)
+          FPM::Cookery::Book.instance.inject_class_methods!(klass)
         end
       end
     end

data/lib/fpm/cookery/chain_packager.rb

@@ -1,5 +1,6 @@
 require 'fpm/cookery/packager'
 require 'fpm/cookery/omnibus_packager'
+require 'fpm/cookery/exceptions'
 
 module FPM
   module Cookery
@@ -20,8 +21,9 @@ module FPM
         recipe.chain_recipes.each do |name|
           recipe_file = build_recipe_file_path(name)
           unless File.exists?(recipe_file)
-            Log.fatal "Cannot find a recipe for #{name} at #{recipe_file}"
-            exit 1
+            error_message = "Cannot find a recipe for #{name} at #{recipe_file}"
+            Log.fatal error_message
+            raise Error::ExecutionFailure, error_message
           end
           FPM::Cookery::Book.instance.load_recipe(recipe_file, config) do |dep_recipe|
             depPackager = FPM::Cookery::Packager.new(dep_recipe, config.to_hash)

data/lib/fpm/cookery/cli.rb

@@ -27,10 +27,20 @@ module FPM
         :attribute_name => 'pkg_dir'
       option '--cache-dir', 'DIR', 'directory for downloaded sources',
         :attribute_name => 'cache_dir'
+      option '--data-dir', 'DIR', 'directory for Hiera data files',
+        :attribute_name => 'data_dir'
+      option '--hiera-config', 'FILE', 'Hiera configuration file',
+        :attribute_name => 'hiera_config'
       option '--skip-package', :flag, 'do not call FPM to build the package',
         :attribute_name => 'skip_package'
+      option '--vendor-delimiter', 'DELIMITER', 'vendor delimiter for version string',
+        :attribute_name => 'vendor_delimiter'
 
       class Command < self
+        def self.add_recipe_parameter!
+          parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        end
+
         def recipe_file
           file = File.expand_path(recipe)
 
@@ -76,6 +86,8 @@ module FPM
 
             exec(config, recipe, packager)
           end
+        rescue Error::ExecutionFailure, Error::Misconfiguration
+          exit 1
         end
 
         def show_version
@@ -102,7 +114,7 @@ module FPM
       end
 
       class PackageCmd < Command
-        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        add_recipe_parameter!
 
         def exec(config, recipe, packager)
           if recipe.omnibus_package == true
@@ -116,7 +128,7 @@ module FPM
       end
 
       class CleanCmd < Command
-        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        add_recipe_parameter!
 
         def exec(config, recipe, packager)
           packager.cleanup
@@ -124,7 +136,7 @@ module FPM
       end
 
       class InstallDepsCmd < Command
-        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        add_recipe_parameter!
 
         def exec(config, recipe, packager)
           packager.install_deps
@@ -132,7 +144,7 @@ module FPM
       end
 
       class InstallBuildDepsCmd < Command
-        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        add_recipe_parameter!
 
         def exec(config, recipe, packager)
           if recipe.omnibus_package == true
@@ -146,13 +158,40 @@ module FPM
       end
 
       class ShowDepsCmd < Command
-        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+        add_recipe_parameter!
 
         def exec(config, recipe, packager)
           puts recipe.depends_all.join(' ')
         end
       end
 
+      class InspectCmd < Command
+        add_recipe_parameter!
+
+        option ['-F', '--format'], 'TEMPLATE', 'ERB template string'
+        option '--terse', :flag, 'show recipe data in compact form'
+
+        self.description = <<DESCRIPTION
+With --format, templates and prints an ERB string with recipe attributes.
+
+Example:
+
+  # Given a recipe with name "foo", version "1.1", revision "12":
+  $ fpm-cook inspect -t rpm --format "<%= name %>-<%= version %>-<%= revision %>.rpm"
+  foo-1.1-12.rpm
+
+Without --format, prints a JSON representation of the recipe.
+DESCRIPTION
+
+        def exec(config, recipe, packager)
+          unless format.nil?
+            puts recipe.template(format)
+          else
+            puts terse? ? recipe.to_json : recipe.to_pretty_json
+          end
+        end
+      end
+
       self.default_subcommand = 'package'
 
       subcommand 'package', 'builds the package', PackageCmd
@@ -160,6 +199,7 @@ module FPM
       subcommand 'install-deps', 'installs build and runtime dependencies', InstallDepsCmd
       subcommand 'install-build-deps', 'installs build dependencies', InstallBuildDepsCmd
       subcommand 'show-deps', 'show build and runtime dependencies', ShowDepsCmd
+      subcommand 'inspect', 'inspect recipe attributes', InspectCmd
     end
   end
 end

data/lib/fpm/cookery/config.rb

@@ -7,7 +7,8 @@ module FPM
       ATTRIBUTES = [
         :color, :debug, :target, :platform, :maintainer, :vendor,
         :skip_package, :keep_destdir, :dependency_check, :quiet,
-        :tmp_root, :pkg_dir, :cache_dir
+        :tmp_root, :pkg_dir, :cache_dir, :data_dir, :hiera_config,
+        :vendor_delimiter
       ].freeze
 
       DEFAULTS = {

data/lib/fpm/cookery/environment.rb

@@ -2,27 +2,36 @@ require 'fpm/cookery/log'
 
 module FPM
   module Cookery
-    class Environment
+    class Environment < Hash
       REMOVALS = %w(
         BUNDLE_GEMFILE RUBYOPT BUNDLE_BIN_PATH GEM_HOME GEM_PATH
       ).freeze
 
-      def initialize
-        @env = {}
+      # Coerce keys and values to +String+s on creation
+      def self.[](h = {})
+        super(Hash[h.map { |k, v| [k.to_s, v.to_s] }])
       end
 
       def [](key)
-        @env[key.to_s]
+        super(key.to_s)
       end
 
       def []=(key, value)
         if value.nil?
-          @env.delete(key.to_s)
+          delete(key.to_s)
         else
-          @env[key.to_s] = value.to_s
+          super(key.to_s, value.to_s)
         end
       end
 
+      def merge(other)
+        super(self.class[other])
+      end
+
+      def merge!(other)
+        super(self.class[other])
+      end
+
       def with_clean
         saved_env = ENV.to_hash
 
@@ -31,7 +40,7 @@ module FPM
           Log.debug("Removing '#{var}' => '#{value}' from environment")
         end
 
-        @env.each do |k, v|
+        each do |k, v|
           Log.debug("Adding '#{k}' => '#{v}' to environment")
           ENV[k] = v
         end
@@ -42,7 +51,7 @@ module FPM
       end
 
       def to_hash
-        @env.dup
+        Hash[self]
       end
     end
   end

data/lib/fpm/cookery/exceptions.rb

@@ -1,7 +1,9 @@
 module FPM
   module Cookery
     class Error < StandardError
-      MethodNotImplemented = Class.new(self)
+      MethodNotImplemented  = Class.new(self)
+      ExecutionFailure      = Class.new(self)
+      Misconfiguration      = Class.new(self)
 
       class InvalidConfigKey < self
         attr_accessor :invalid_keys

data/lib/fpm/cookery/facts.rb

@@ -3,41 +3,56 @@ require 'facter'
 module FPM
   module Cookery
     class Facts
-      def self.arch
-        @arch ||= Facter.fact(:architecture).value.downcase.to_sym
-      end
-
-      def self.platform
-        @platform ||= Facter.fact(:operatingsystem).value.downcase.to_sym
-      end
-
-      def self.platform=(value)
-        @platform = value.downcase.to_sym
-      end
-
-      def self.osrelease
-        @osrelease ||= Facter.fact(:operatingsystemrelease).value
-      end
-
-      def self.osmajorrelease
-        @osmajorrelease ||= Facter.fact(:operatingsystemmajrelease).value
-      end
-
-      def self.target
-        @target ||= case platform
-                    when :centos, :redhat, :fedora, :amazon,
-                         :scientific, :oraclelinux           then :rpm
-                    when :debian, :ubuntu                    then :deb
-                    when :darwin                             then :osxpkg
-                    end
-      end
-
-      def self.target=(value)
-        @target = value.to_sym
-      end
-
-      def self.reset!
-        instance_variables.each {|v| instance_variable_set(v, nil) }
+      class << self
+        def arch
+          @arch ||= value(:architecture)
+        end
+
+        def platform
+          @platform ||= value(:operatingsystem)
+        end
+
+        def platform=(value)
+          @platform = value.downcase.to_sym
+        end
+
+        def osrelease
+          @osrelease ||= value(:operatingsystemrelease, false)
+        end
+
+        def lsbcodename
+          @lsbcodename ||= value(:lsbcodename)
+        end
+
+        def osmajorrelease
+          @osmajorrelease ||= value(:operatingsystemmajrelease, false)
+        end
+
+        def target
+          @target ||= case platform
+                      when :centos, :redhat, :fedora, :amazon,
+                           :scientific, :oraclelinux           then :rpm
+                      when :debian, :ubuntu                    then :deb
+                      when :darwin                             then :osxpkg
+                      when :alpine                             then :apk
+                      end
+        end
+
+        def target=(value)
+          @target = value.to_sym
+        end
+
+        def reset!
+          instance_variables.each {|v| instance_variable_set(v, nil) }
+        end
+
+        private
+
+        def value(fact_name, symbolize = true)
+          v = Facter.value(fact_name)
+          return v if v.nil? or !symbolize
+          return v.downcase.to_sym
+        end
       end
     end
   end

data/lib/fpm/cookery/hiera.rb

@@ -0,0 +1,35 @@
+require 'hiera'
+require 'fpm/cookery/hiera/defaults'
+require 'fpm/cookery/hiera/scope'
+require 'fpm/cookery/log/hiera'
+
+module FPM
+  module Cookery
+    # Implement Hiera lookups and interpolation for recipes
+    module Hiera
+      # +Hiera+ subclass that wraps a recipe class
+      class Instance < ::Hiera
+        include FPM::Cookery::Hiera::Defaults
+
+        attr_reader :recipe, :scope
+
+        # Expects a recipe class and a hash containing one key, +:config+.
+        def initialize(recipe, options = {})
+          @recipe = recipe
+          @scope = Scope.new(recipe)
+
+          # For some reason, +Hiera+'s constructor expects a hash with just the
+          # one key.
+          super({ :config => hiera_config(options) })
+        end
+
+        # Provides a default scope, and attempts to look up the key both as a
+        # string and as a symbol.
+        def lookup(key, default = nil, scope = self.scope, *rest)
+          super(key.to_sym, default, scope, *rest) || super(key.to_s, default, scope, *rest)
+        end
+        alias_method :[], :lookup
+      end
+    end
+  end
+end

data/lib/fpm/cookery/hiera/defaults.rb

@@ -0,0 +1,50 @@
+module FPM
+  module Cookery
+    module Hiera
+      module Defaults
+        module_function
+
+        # This will result in Hiera using the +Hiera::Fpm_cookery_logger+ class
+        # for logging.
+        def hiera_logger
+          'fpm_cookery'
+        end
+
+        # Sets the default search hierarchy.  +Hiera+ will look for files
+        # matching +"#{ENV['FPM_ENV']}.yaml"+, etc.
+        # Note: the including class is expected to define a +recipe+ method
+        # that responds to +platform+ and +target+.
+        def hiera_hierarchy
+          ['common']
+        end
+
+        # Default to attempting lookups using both +.yaml+ and +.json+ files.
+        def hiera_backends
+          [:yaml, :json]
+        end
+
+        def hiera_datadir
+          File.join(Dir.getwd, 'config')
+        end
+
+        # Sets default values for the +{:config => { ... }}+ options hash
+        # passed to the +Hiera+ constructor, merging in any options from the
+        # caller.
+        def hiera_config(options = {})
+          # Hiera accepts a path to a configuration file or a hash; short
+          # circuit if it's the former.
+          return options[:config] unless options[:config].is_a?(Hash)
+
+          {
+            :logger     => hiera_logger,
+            :hierarchy  => hiera_hierarchy,
+            :yaml       => { :datadir  => hiera_datadir },
+            :json       => { :datadir  => hiera_datadir },
+            :backends   => hiera_backends
+          }.merge options[:config] || {}
+        end
+      end
+    end
+  end
+end
+

data/lib/fpm/cookery/hiera/scope.rb

@@ -0,0 +1,35 @@
+require 'facter'
+require 'fpm/cookery/facts'
+
+module FPM
+  module Cookery
+    module Hiera
+      # Wraps a recipe class, adding a +[]+ method so that it can be used as a
+      # +Hiera+ scope.
+      class Scope
+        attr_reader :recipe
+
+        def initialize(recipe)
+          @recipe = recipe
+        end
+
+        # Allow Hiera to perform +%{scope("key")}+ interpolations using data
+        # from the recipe class, +FPM::Cookery::Facts+, and +Facter+.  Expects
+        # +name+ to be a method name or +Facter+ fact name.  Returns the result
+        # of the lookup.  Will be +nil+ if lookup failed to fetch a result.
+        def [](name)
+          [recipe, FPM::Cookery::Facts].each do |source|
+            if source.respond_to?(name)
+              return source.send(name)
+            end
+          end
+
+          # As a backup, try to retrieve it from +Facter+.
+          unless (result = Facter[name]).nil?
+            result.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fpm/cookery/inheritable_attr.rb

@@ -0,0 +1,222 @@
+# Credit due to Nick Sutterer, whose +Uber::InheritableAttr+ provides much
+# of the code that appears with modification here.
+# @see https://github.com/apotonick/uber
+# @see https://raw.githubusercontent.com/apotonick/uber/master/LICENSE
+
+# +Uber+'s license reproduced here:
+#  # Copyright (c) 2012 Nick Sutterer
+#
+#  MIT License
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'fpm/cookery/path'
+
+module FPM
+  module Cookery
+    # Provides inheritance of class-level attributes. Attributes are cloned
+    # from the superclass, except for non-clonable attributes, which are
+    # assigned directly.
+    #
+    # This module will automatically define class methods for keeping track of
+    # inheritable attributes, as follows:
+    #   +attr_rw+       => +klass.scalar_attrs+
+    #   +attr_rw_list+  => +klass.list_attrs+
+    #   +attr_rw_hash+  => +klass.hash_attrs+
+    #   +attr_rw_path+  => +klass.path_attrs+
+    #
+    # @example
+    #   class Foo
+    #     extend FPM::Cookery::InheritableAttr
+    #
+    #     attr_rw       :name, :rank
+    #     attr_rw_list  :favorite_things
+    #     attr_rw_hash  :meta
+    #     attr_rw_path  :home
+    #
+    #     name("J.J. Jingleheimer-Schmidt")
+    #     favorite_things("brown paper packages", "raindrops on roses")
+    #     meta[:data] = "la la la la la la la la"
+    #     home = "/home/jjschmidt"
+    #   end
+    #
+    #   Bar = Class.new(Foo)
+    #   Bar.home                #=> #<FPM::Cookery::Path:/home/jjschmidt>
+    #   Bar.home = "/home/free" #=> #<FPM::Cookery::Path:/home/free>
+    #   Foo.home                #=> #<FPM::Cookery::Path:/home/jjschmidt>
+    #
+    #   Foo.scalar_attrs        #=> [:name, :rank]
+    #   Foo.list_attrs          #=> [:favorite_things]
+    #   Foo.hash_attrs          #=> [:meta]
+    #   Foo.path_attrs          #=> [:home]
+    module InheritableAttr
+      # Adds a list of attributes keyed to the +type+ key of an internal hash
+      # tracking class attributes. Also defines the method +"#{type}_attrs"+,
+      # which will return the list of attribute names keyed to +type+.
+      # @example
+      def register_attrs(type, *attrs)
+        (attr_registry[type] ||= []).concat(attrs)
+
+        unless respond_to?(type_reader = :"#{type}_attrs")
+          (class << self ; self ; end).send(:define_method, type_reader) do
+            attr_registry.fetch(type, []).dup
+          end
+        end
+      end
+
+      # Create `scalar' (i.e. non-collection) attributes.
+      def attr_rw(*attrs)
+        attrs.each do |attr|
+          class_eval %Q{
+            def self.#{attr}(value = nil)
+              if value.nil?
+                return @#{attr} if instance_variable_defined?(:@#{attr})
+                @#{attr} = InheritableAttr.inherit_for(self, :#{attr})
+              else
+                @#{attr} = value
+              end
+            end
+
+            def #{attr}
+              self.class.#{attr}
+            end
+          }
+        end
+
+        register_attrs(:scalar, *attrs)
+      end
+
+      # Create list-style attributes, backed by +Array+s. +nil+ entries will be
+      # filtered, non-unique entries will be culled to one instance only, and
+      # the list will be flattened.
+      def attr_rw_list(*attrs)
+        attrs.each do |attr|
+          class_eval %Q{
+            def self.#{attr}(*list)
+              unless instance_variable_defined?(:@#{attr})
+                @#{attr} = InheritableAttr.inherit_for(self, :#{attr})
+              end
+
+              @#{attr} ||= []
+
+              unless list.empty?
+                @#{attr} << list
+                @#{attr}.flatten!
+                @#{attr}.uniq!
+              end
+
+              @#{attr}
+            end
+
+            def #{attr}
+              self.class.#{attr}
+            end
+          }
+        end
+
+        register_attrs(:list, *attrs)
+      end
+
+      # Create +Hash+-style attributes.  Supports both hash and argument
+      # assignment:
+      #   attr_method[:attr1] = xxxx
+      #   attr_method :xxxx=>1, :yyyy=>2
+      def attr_rw_hash(*attrs)
+        attrs.each do |attr|
+          class_eval %Q{
+            def self.#{attr}(args = {})
+              unless instance_variable_defined?(:@#{attr})
+                @#{attr} = InheritableAttr.inherit_for(self, :#{attr})
+              end
+
+              (@#{attr} ||= {}).merge!(args)
+            end
+
+            def #{attr}
+              self.class.#{attr}
+            end
+          }
+        end
+
+        register_attrs(:hash, *attrs)
+      end
+
+      # Create methods for attributes representing paths.  Arguments to
+      # writer methods will be converted to +FPM::Cookery::Path+ objects.
+      def attr_rw_path(*attrs)
+        attrs.each do |attr|
+          class_eval %Q{
+            def self.#{attr}
+              return @#{attr} if instance_variable_defined?(:@#{attr})
+              @#{attr} = InheritableAttr.inherit_for(self, :#{attr})
+            end
+
+            def self.#{attr}=(value)
+              @#{attr} = FPM::Cookery::Path.new(value)
+            end
+
+            def #{attr}=(value)
+              self.class.#{attr} = value
+            end
+
+            def #{attr}(path = nil)
+              self.class.#{attr}(path)
+            end
+          }
+        end
+
+        register_attrs(:path, *attrs)
+      end
+
+      class << self
+        def inherit_for(klass, name)
+          return unless klass.superclass.respond_to?(name)
+          DeepClone.(klass.superclass.send(name))
+        end
+
+        def extended(klass)
+          # Inject the +attr_registry+ attribute into any class that extends
+          # this module.
+          klass.attr_rw_hash(:attr_registry)
+        end
+      end
+
+      # Provides deep cloning of data structures. Used in
+      # +InheritableAttr.inherit_for+ to, among other things, avoid
+      # accidentally propagating to the superclass changes made to
+      # substructures of an attribute (such as arrays contained in a hash
+      # attribute).
+      class DeepClone
+        def self.call(obj)
+          case obj
+            when Hash
+              obj.class[obj.map { |k, v| [DeepClone.(k), DeepClone.(v)] }]
+            when Array
+              obj.map { |v| DeepClone.(v) }
+            when Symbol, TrueClass, FalseClass, NilClass, Integer, Float
+              obj
+            else
+              obj.respond_to?(:clone) ? obj.clone : obj
+          end
+        end
+      end
+    end
+  end
+end