fpm-cookery 0.15.0 → 0.16.0

data/.travis.yml

@@ -0,0 +1,10 @@
+script: rake test
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v0.16.0 (2013-09-21)
+* Chain packager. (smasset)
+* Add show-depends CLI option. (unakatsuo)
+* Add fpm-cookery chain packager gem recipes. (smasset)
+* Compatibility fixes for the latest FPM releases. (skiold)
+* Fix problems with tar files that contain no directories. (narkisr)
+* New CLI options parsing backend. (using clamp)
+
 # v0.15.0 (2013-06-13)
 * Add --no-deps option to disable dependency checks.
 

data/bin/fpm-cook

@@ -4,4 +4,4 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
 require 'fpm/cookery/cli'
 
-FPM::Cookery::CLI.new.args(ARGV).run
+FPM::Cookery::CLI.run

data/fpm-cookery.gemspec

@@ -18,10 +18,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "minitest", "~> 4.0"
+  s.add_development_dependency "minitest", "~> 5.0"
   s.add_development_dependency "rake"
   s.add_runtime_dependency "fpm", "~> 0.4"
   s.add_runtime_dependency "facter"
   s.add_runtime_dependency "puppet"
   s.add_runtime_dependency "addressable"
+  s.add_runtime_dependency "systemu"
 end

data/lib/fpm/cookery/chain_packager.rb

@@ -0,0 +1,58 @@
+require 'fpm/cookery/packager'
+require 'fpm/cookery/omnibus_packager'
+
+module FPM
+  module Cookery
+    class ChainPackager
+      include FPM::Cookery::Utils
+
+      attr_reader :packager, :recipe, :config
+
+      def initialize(packager, config = {})
+        @packager = packager
+        @recipe = packager.recipe
+        @config = config
+      end
+
+      def run
+        Log.info "Recipe #{recipe.name} is a chain package; looking for child recipes to build"
+
+        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
+          end
+
+          Log.info "Located recipe at #{recipe_file} for child recipe #{name}; starting build"
+
+          FPM::Cookery::Book.instance.load_recipe(recipe_file) do |dep_recipe|
+            depPackager = FPM::Cookery::Packager.new(dep_recipe, config)
+            depPackager.target = FPM::Cookery::Facts.target.to_s
+
+            #Chain, chain, chain ...
+            if dep_recipe.omnibus_package == true
+              FPM::Cookery::OmnibusPackager.new(depPackager, config).run
+            elsif dep_recipe.chain_package == true
+              FPM::Cookery::ChainPackager.new(depPackager, config).run
+            else
+              depPackager.dispense
+            end
+          end
+
+          Log.info "Finished building #{name}, moving on to next recipe"
+        end
+
+        packager.dispense
+      end
+
+      private
+
+      def build_recipe_file_path(name)
+        # Look for recipes in the same dir as the recipe we loaded
+        File.expand_path(File.dirname(recipe.filename) + "/#{name}.rb")
+      end
+    end
+  end
+end

data/lib/fpm/cookery/cli.rb

@@ -2,51 +2,74 @@ require 'fpm/cookery/book_hook'
 require 'fpm/cookery/recipe'
 require 'fpm/cookery/facts'
 require 'fpm/cookery/packager'
+require 'fpm/cookery/chain_packager'
 require 'fpm/cookery/omnibus_packager'
 require 'fpm/cookery/log'
 require 'fpm/cookery/log/output/console'
 require 'fpm/cookery/log/output/console_color'
-require 'optparse'
+require 'fpm/cookery/config'
+require 'clamp'
 
 module FPM
   module Cookery
-    class CLI
-      def initialize
-        @colors = true
-        @debug = false
-      end
+    class CLI < Clamp::Command
+      option ['-c', '--color'], :flag, 'toggle color'
+      option ['-D', '--debug'], :flag, 'enable debug output'
+      option ['-t', '--target'], 'TARGET', 'set desired fpm output target (deb, rpm, etc)'
+      option ['-p', '--platform'], 'PLATFORM', 'set the target platform (centos, ubuntu, debian)'
+      option ['-V', '--version'], :flag, 'show fpm-cookery and fpm version'
+      option '--[no-]deps', :flag, 'enable/disable dependency checking',
+        :attribute_name => 'dependency_check'
+
+      class Command < self
+        def recipe_file
+          file = File.expand_path(recipe)
 
-      def args(argv)
-        program = File.basename($0)
-        options = OptionParser.new
-        options.banner = \
-          "Usage: #{program} [options] [path/to/recipe.rb] action [...]"
-        options.separator "Actions:"
-        options.separator "  package        - builds the package"
-        options.separator "  clean          - cleans up"
-        options.separator "  install-deps   - installs build and runtime dependencies"
-        options.separator "Options:"
-
-        options.on("-c", "--color",
-                   "Toggle color. (default #{@colors.inspect})") do |o|
-          @colors = !@colors
-        end
+          # Allow giving the directory containing a recipe.rb
+          if File.directory?(file) && File.exists?(File.join(file, 'recipe.rb'))
+            file = File.join(file, 'recipe.rb')
+          end
 
-        options.on("-D", "--debug", "Enable debug output.") do |o|
-          @debug = true
+          file
         end
 
-        options.on("-t TARGET", "--target TARGET",
-                  "Set the desired fpm output target (deb, rpm, etc)") do |o|
-          @target = o
+        def validate
+          unless File.exists?(recipe_file)
+            Log.error 'No recipe.rb found in the current directory, abort.'
+            exit 1
+          end
+
+          # Override the detected platform.
+          if platform
+            FPM::Cookery::Facts.platform = platform
+          end
+
+          if target
+            FPM::Cookery::Facts.target = target
+          end
+
+          if FPM::Cookery::Facts.target.nil?
+            Log.error "No target given and we're unable to detect your platform"
+            exit 1
+          end
         end
 
-        options.on("-p PLATFORM", "--platform PLATFORM",
-                  "Set the target platform. (centos, ubuntu, debian)") do |o|
-          @platform = o
+        def execute
+          show_version if version?
+          init_logging
+          validate
+
+          FPM::Cookery::BaseRecipe.send(:include, FPM::Cookery::BookHook)
+
+          FPM::Cookery::Book.instance.load_recipe(recipe_file) do |recipe|
+            packager = FPM::Cookery::Packager.new(recipe, :dependency_check => config.dependency_check)
+            packager.target = FPM::Cookery::Facts.target.to_s
+
+            exec(config, recipe, packager)
+          end
         end
 
-        options.on("-V", "--version", "Show fpm-cookery and fpm version") do
+        def show_version
           require 'fpm/version'
           require 'fpm/cookery/version'
 
@@ -54,99 +77,65 @@ module FPM
           exit 0
         end
 
-        options.on("--no-deps", "Disable dependency checking") do |o|
-          @nodep = true
+        def config
+          @config ||= FPM::Cookery::Config.from_cli(self)
         end
 
-        # Parse flags and such, remainder is all non-option args.
-        remainder = options.parse(argv)
+        def init_logging
+          FPM::Cookery::Log.enable_debug(config.debug)
 
-        # Initialize logging.
-        FPM::Cookery::Log.enable_debug(@debug)
-        if @colors
-          FPM::Cookery::Log.output(FPM::Cookery::Log::Output::ConsoleColor.new)
-        else
-          FPM::Cookery::Log.output(FPM::Cookery::Log::Output::Console.new)
+          if config.color?
+            FPM::Cookery::Log.output(FPM::Cookery::Log::Output::ConsoleColor.new)
+          else
+            FPM::Cookery::Log.output(FPM::Cookery::Log::Output::Console.new)
+          end
         end
+      end
 
-        # Default recipe to find is in current directory named 'recipe.rb'
-        @filename = File.expand_path('recipe.rb')
-
-        # See if something that looks like a recipe path is in arguments
-        remainder.each do |arg|
-          # If 'foo.rb' was given, and it exists, use it.
-          if arg =~ /\.rb$/ and File.exists?(arg)
-            remainder.delete(arg)
-            @filename = arg
-            break
-          end
+      class PackageCmd < Command
+        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
 
-          # Allow giving the directory containing a recipe.rb
-          if File.directory?(arg) and File.exists?(File.join(arg, "recipe.rb"))
-            remainder.delete(arg)
-            @filename = File.join(arg, "recipe.rb")
-            break
+        def exec(config, recipe, packager)
+          if recipe.omnibus_package == true
+            FPM::Cookery::OmnibusPackager.new(packager).run
+          elsif recipe.chain_package == true
+            FPM::Cookery::ChainPackager.new(packager, :dependency_check => config.dependency_check).run
+          else
+            packager.dispense
           end
         end
-
-        # Everything that's not the recipe filename is an action.
-        @actions = remainder
-        return self
       end
 
-      def validate
-        unless File.exists?(@filename)
-          Log.error 'No recipe.rb found in the current directory, abort.'
-          exit 1
-        end
-
-        # Default action is "package"
-        if @actions.empty?
-          @actions = ["package"]
-        end
+      class CleanCmd < Command
+        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
 
-        # Override the detected platform.
-        if @platform
-          FPM::Cookery::Facts.platform = @platform
+        def exec(config, recipe, packager)
+          packager.cleanup
         end
+      end
 
-        if @target
-          FPM::Cookery::Facts.target = @target
-        end
+      class InstallDepsCmd < Command
+        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
 
-        if FPM::Cookery::Facts.target.nil?
-          Log.error "No target given and we're unable to detect your platform"
-          exit 1
+        def exec(config, recipe, packager)
+          packager.install_deps
         end
-
       end
 
-      def run
-        validate
-
-        FPM::Cookery::Recipe.send(:include, FPM::Cookery::BookHook)
-
-        FPM::Cookery::Book.instance.load_recipe(@filename) do |recipe|
-          packager = FPM::Cookery::Packager.new(recipe, :dependency_check => !@nodep)
-          packager.target = FPM::Cookery::Facts.target.to_s
-
-          @actions.each do |action|
-            case action
-            when "clean" ; packager.cleanup
-            when "package"
-              if recipe.omnibus_package == true
-                FPM::Cookery::OmnibusPackager.new(packager).run
-              else
-                packager.dispense
-              end
-            when "install-deps" ; packager.install_deps
-            else
-              # TODO(sissel): fail if this happens
-              Log.error "Unknown action: #{action}"
-            end
-          end
+      class ShowDepsCmd < Command
+        parameter '[RECIPE]', 'the recipe file', :default => 'recipe.rb'
+
+        def exec(config, recipe, packager)
+          puts recipe.depends_all.join(' ')
         end
       end
+
+      self.default_subcommand = 'package'
+
+      subcommand 'package', 'builds the package', PackageCmd
+      subcommand 'clean', 'cleans up', CleanCmd
+      subcommand 'install-deps', 'installs build and runtime dependencies', InstallDepsCmd
+      subcommand 'show-deps', 'show build and runtime dependencies', ShowDepsCmd
     end
   end
 end

data/lib/fpm/cookery/config.rb

@@ -0,0 +1,86 @@
+require 'yaml'
+require 'fpm/cookery/exceptions'
+
+module FPM
+  module Cookery
+    class Config
+      ATTRIBUTES = [
+        :color, :debug, :target, :platform, :maintainer, :vendor,
+        :skip_package, :keep_destdir, :dependency_check
+      ].freeze
+
+      DEFAULTS = {
+        :color => true,
+        :debug => false,
+        :dependency_check => true,
+        :skip_package => false,
+        :keep_destdir => false
+      }.freeze
+
+      def self.load_file(paths)
+        path = Array(paths).find {|p| File.exist?(p) }
+
+        path ? new(YAML.load_file(path)) : new
+      end
+
+      def self.from_cli(cli)
+        new.tap do |config|
+          ATTRIBUTES.each do |name|
+            if cli.respond_to?("#{name}?")
+              value = cli.__send__("#{name}?")
+            elsif cli.respond_to?(name)
+              value = cli.__send__(name)
+            else
+              value = nil
+            end
+
+            config.__send__("#{name}=", value) unless value.nil?
+          end
+        end
+      end
+
+      attr_accessor *ATTRIBUTES
+
+      ATTRIBUTES.each do |name|
+        class_eval %Q(
+          def #{name}?
+            !!#{name}
+          end
+        )
+      end
+
+      def initialize(data = {})
+        validate_input(data)
+
+        DEFAULTS.merge(data).each do |key, value|
+          self.__send__("#{key}=", value)
+        end
+      end
+
+      def to_hash
+        ATTRIBUTES.inject({}) do |hash, attribute|
+          hash[attribute] = __send__(attribute)
+          hash
+        end
+      end
+
+      private
+
+      def validate_input(data)
+        errors = []
+
+        data.keys.each do |key|
+          unless ATTRIBUTES.include?(key.to_sym)
+            errors << key
+          end
+        end
+
+        unless errors.empty?
+          e = Error::InvalidConfigKey.new("Invalid config keys: #{errors.join(', ')}")
+          e.invalid_keys = errors
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/fpm/cookery/dependency_inspector.rb

@@ -15,9 +15,7 @@ module FPM
 
         Log.info "Verifying build_depends and depends with Puppet"
 
-        missing = (build_depends + depends).reject do |package|
-          self.package_installed?(package)
-        end
+        missing = missing_packages(build_depends + depends)
 
         if missing.length == 0
           Log.info "All build_depends and depends packages installed"
@@ -36,6 +34,12 @@ module FPM
 
       end
 
+      def self.missing_packages(*pkgs)
+        pkgs.flatten.reject do |package|
+          self.package_installed?(package)
+        end
+      end
+
       def self.package_installed?(package)
         Log.info("Verifying package: #{package}")
         return unless self.package_suitable?(package)