kafo 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cec1cec4f897c23ed85f473caca2b1e9fc7feea7
-  data.tar.gz: 5cd2bb6b161e2fdbf71e42425df0179cad53226b
+  metadata.gz: b6baa0a37138d0cf9c3507b1447bd5f67d7f081b
+  data.tar.gz: d48cdf33c7943f2108e8a02d10a575a2cec960d3
 SHA512:
-  metadata.gz: ad300f9ee839582ea0b81b26861f75347280f9ab746bcf7c70130141c430f7dcf5da98e62671912053c5bb4e0fe98b4feb8020af63468288dbee5681909643e7
-  data.tar.gz: 7ea593a6fda67a94dbb9daaa88ac9138086e974d7fec9c62737c76145445334e8ef783dae6ffab8a99f3253525e4f45bed55640a9b1a9e4d8c81aa5d6d79ae35
+  metadata.gz: 8fbce457e4181cee9428bbc92ecbae2adb3714f0b4813ec155cbd345c56ab9468e2d39becfba8e638ab671fb22e7a9ceec72608e1027a045cb15284566f53384
+  data.tar.gz: 8e70ebdd67e493754da42ca37750f39bc650dd2357f89f9875331318b1fe54d0463f22299cad7b9128afe956d0aafb4afc21752cf3608e7a63083f7e6092ad84

data/README.md

@@ -488,41 +488,92 @@ It also works in interactive mode.
 ## Hooks
 
 You may need to add new features to the installer. Kafo provides simple hook
-mechanism that allows you to run custom code just before and after the puppet
-is ran. Let's assume we want to add --reset-foreman-db option to our
-foreman-installer. We add following lines to generated installer script
+mechanism that allows you to run custom code at various time. We support
+several hooks.
+
+* boot - before kafo is ready to work, useful for adding new installer arguments, logger won't work yet
+* init - just after hooking is initialized and kafo is configured, parameters have no values yet
+* pre_values - just before value from CLI is set to parameters (they already have default values)
+* pre  - just before puppet is executed to converge system
+* post  - just after puppet is executed to converge system
+
+Let's assume we want to add --reset-foreman-db option to our
+foreman-installer. We could either add following lines to generated
+installer script.
 
 ```ruby
 require 'kafo/hooking'
 
-# functions specific to foreman installer
-KafoConfigure.app_option '--reset-foreman-db',
-  :flag, 'Drop foreman database first? You will lose all data!', :default => false
+# first hook that creates new app option --reset-foreman-db
+KafoConfigure.hooking.register_boot(:add_reset_option) do
+  app_option '--reset-foreman-db',
+    :flag, 'Drop foreman database first? You will lose all data!', :default => false
+end
 
-KafoConfigure.hooking.register_pre(:reset_db) do |kafo|
-  if kafo.config.app[:reset_foreman_db] && !kafo.config.app[:noop]
+# second hook which resets the db if value was set to true
+KafoConfigure.hooking.register_pre(:reset_db) do
+  if app_value(:reset_foreman_db) && !app_value(:noop)
     `which foreman-rake > /dev/null 2>&1`
     if $?.success?
-      KafoConfigure.logger.info 'Dropping database!'
+      logger.info 'Dropping database!'
       output = `foreman-rake db:drop 2>&1`
-      KafoConfigure.logger.debug output.to_s
+      logger.debug output.to_s
       unless $?.success?
-        KafoConfigure.logger.warn "Unable to drop DB, ignoring since it's not fatal, output was: '#{output}''"
+        logger.warn "Unable to drop DB, ignoring since it's not fatal, output was: '#{output}''"
       end
     else
-      KafoConfigure.logger.warn 'Foreman not installed yet, can not drop database!'
+      logger.warn 'Foreman not installed yet, can not drop database!'
+    end
+  end
+end
+```
+
+Note that the hook is evaluated in HookContext object which provides some DSL. We can create
+new installer option using ```app_option```. These option values can be accessed by using
+```app_value(:reset_foreman_db)```. You can modify parameters (if they are already defined)
+using ```param('module name', 'parameter name')``` accessor. Last but not least you have
+access to logger. For more details, see hook_context.rb.
+
+If you don't want to modify you installer script you can place your hooks into
+hooks directory. By default hooks dir is searched for ruby files in subdirectories
+based on hook type. For example pre hooks are searched for in ```$installer_dir/hooks/pre/*.rb```
+Hooks from previous example would look like this. The only change to the code is 
+that you don't explicitely register hooks, it's done automatically for you.
+
+```ruby
+# hooks/boot/10-add_reset_option.rb
+app_option '--reset-foreman-db', :flag, 'Drop foreman database first? You will lose all data!', :default => false
+```
+
+```ruby
+# hooks/pre/10-reset_option_feature.rb
+if app_value(:reset_foreman_db) && !app_value(:noop)
+  `which foreman-rake > /dev/null 2>&1`
+  if $?.success?
+    logger.info 'Dropping database!'
+    output = `foreman-rake db:drop 2>&1`
+    logger.debug output.to_s
+    unless $?.success?
+      logger.warn "Unable to drop DB, ignoring since it's not fatal, output was: '#{output}''"
     end
+  else
+    logger.warn 'Foreman not installed yet, can not drop database!'
   end
 end
 ```
 
-Note that we can access other installer options using ```kafo.config.app```. Since ```kafo``` is
-KafoConfigure instance, you can even access puppet params values. Last but not least you have
-access to logger.
 
-You can register as many hooks as you need. They are executed in unspecified order. Every hook
-must have a unique name. In a very similar way you can register :post hooks that are executed
-right after puppet run is over.
+If you want to add more directories to be search you can use hook_dirs option
+in installer configuration file.
+
+```yaml
+:hook_dirs:
+- /opt/hooks
+- /my/plugin/hooks
+```
+
+You can register as many hooks as you need. The order of execution for particular hook type 
+is based on hook file name.
 
 ## Colors
 

data/bin/kafofy

@@ -30,7 +30,7 @@ options[:name] ||= "kafo-configure"
 options[:config_file] ||= "./config/#{options[:name]}.yaml"
 
 # Create directory structure
-%w(bin config modules).each do |dir|
+%w(bin config modules hooks).each do |dir|
   FileUtils.mkdir_p dir
 end
 

data/config/kafo.yaml.example

@@ -36,3 +36,9 @@
 # :log_group: root
 # :config_header_file:
 # :dont_save_answers:
+
+## Hooks - hooks in these extra directories will be loaded,
+# by default they are loaded from $installer_dir/hooks/$type
+# when you specify your directory, it will be search for $yourdir/$type/*.rb
+# :hooks_dir:
+# - /opt/hooks

data/lib/kafo/configuration.rb

@@ -22,7 +22,8 @@ module Kafo
         :modules_dir         => './modules',
         :default_values_dir  => '/tmp',
         :colors              => Configuration.colors_possible?,
-        :color_of_background => :dark
+        :color_of_background => :dark,
+        :hook_dirs           => []
     }
 
     def initialize(file, persist = true)
@@ -117,7 +118,11 @@ module Kafo
     private
 
     def includes
-      modules.map { |mod| "include #{mod.dir_name}::params" }.join(' ')
+      modules.map do |mod|
+        params_file = File.join(KafoConfigure.modules_dir, modules.first.dir_name, 'manifests', 'params.pp')
+        @logger.debug "checking presence of #{params_file}"
+        File.exist?(params_file) ? "include #{mod.dir_name}::params" : nil
+      end.compact.join(' ')
     end
 
     def params

data/lib/kafo/hook_context.rb

@@ -0,0 +1,51 @@
+module Kafo
+  class HookContext
+    attr_reader :kafo
+
+    def self.execute(kafo, &hook)
+      # TODO can be removed in 0.6, is DEPRECATED since 0.5
+      # instance_exec can be later changed to instance eval when people stop using |kafo| in their hooks
+      # and rely only on hook context DSL
+      if hook.arity > 0
+        kafo.logger.warn "Hook '#{name}' is using block with arguments which is DEPRECATED, access to kafo instance is " +
+                        "provided by hook DSL, please remove |kafo| from your hook block"
+      end
+      new(kafo).instance_exec(kafo, &hook)
+    end
+
+    def initialize(kafo)
+      @kafo = kafo
+    end
+
+    # some of hooks won't print any message because logger is not yet configured
+    # configuration of logger depends on application configration (log level etc.)
+    # examples:
+    #   logger.warn "this combindation of parameters is untested"
+    def logger
+      self.kafo.logger
+    end
+
+    # if you want to add new app_option be sure to do as soon as possible (usually boot hook)
+    # otherwise it may be to late (e.g. when displaying help)
+    # examples:
+    #   app_option '--log-level', 'LEVEL', 'Log level for log file output', :default => config.app[:log_level]:
+    #   app_option ['-n', '--noop'], :flag, 'Run puppet in noop mode?', :default => false
+    def app_option(*args)
+      self.kafo.class.app_option *args
+    end
+
+    # examples:
+    #   app_value(:log_level)
+    # note the dash to underscore convention
+    def app_value(option)
+      self.kafo.config.app[option.to_sym]
+    end
+
+    # examples:
+    #   param('foreman', 'interface').value = 'eth0'
+    #   param('foreman', 'interface').value = app_option('bind_on_interface')
+    def param(module_name, parameter_name)
+      self.kafo.param(module_name, parameter_name)
+    end
+  end
+end

data/lib/kafo/hooking.rb

@@ -1,25 +1,67 @@
+require 'kafo/hook_context'
+
 module Kafo
   class Hooking
+    # boot - before kafo is ready to work, useful for adding new app arguments, logger won't work yet
+    # init - just after hooking is initialized and kafo is configured, parameters have no values yet
+    # pre_values - just before value from CLI is set to parameters (they already have default values)
+    # pre - just before puppet is executed to converge system
+    # post - just after puppet is executed to converge system
+    TYPES = [:boot, :init, :pre, :post, :pre_values]
 
     attr_accessor :hooks, :kafo
 
     def initialize
       self.hooks = Hash.new { |h, k| h[k] = {} }
+      @loaded = false
     end
 
     def logger
       KafoConfigure.logger
     end
 
+    def load
+      base_dirs = [File.join([KafoConfigure.root_dir, 'hooks']), KafoConfigure.config.app[:hook_dirs]]
+      base_dirs.each do |base_dir|
+        TYPES.each do |hook_type|
+          dir = File.join(base_dir, hook_type.to_s)
+          Dir.glob(dir + "/*.rb").sort.each do |file|
+            logger.debug "Loading hook #{file}"
+            hook = File.read(file)
+            hook_block = proc { instance_eval(hook, file, 1) }
+            register(hook_type, file, &hook_block)
+          end
+        end
+        @loaded = true
+      end
+      self
+    end
+
+    def loaded?
+      @loaded
+    end
+
     def execute(group)
       logger.info "Executing hooks in group #{group}"
       self.hooks[group].each_pair do |name, hook|
-        result = hook.call(kafo)
+        result = HookContext.execute(self.kafo, &hook)
         logger.debug "Hook #{name} returned #{result.inspect}"
       end
       logger.info "All hooks in group #{group} finished"
     end
 
+    def register_boot(name, &block)
+      register(:boot, name, &block)
+    end
+
+    def register_init(name, &block)
+      register(:init, name, &block)
+    end
+
+    def register_pre_values(name, &block)
+      register(:pre_values, name, &block)
+    end
+
     def register_pre(name, &block)
       register(:pre, name, &block)
     end

data/lib/kafo/kafo_configure.rb

@@ -9,6 +9,7 @@ end
 
 require 'pty'
 require 'clamp'
+require 'kafo_parsers/exceptions'
 require 'kafo/exceptions'
 require 'kafo/configuration'
 require 'kafo/logger'
@@ -45,10 +46,12 @@ module Kafo
       self.class.gem_root         = File.join(File.dirname(__FILE__), '../../')
       self.class.kafo_modules_dir = self.class.config.app[:kafo_modules_dir] || (self.class.gem_root + '/modules')
       @progress_bar               = nil
+      self.class.hooking.load
       self.class.hooking.kafo     = self
 
       super
 
+      self.class.hooking.execute(:boot)
       set_app_options
       # we need to parse app config params using clamp even before run method does it
       # so we limit parsing only to app config options (because of --help and later defined params)
@@ -57,6 +60,7 @@ module Kafo
       Logger.setup
       ColorScheme.new(config).setup
 
+      self.class.hooking.execute(:init)
       set_parameters # here the params gets parsed and we need app config populated
       set_options
     end
@@ -65,6 +69,10 @@ module Kafo
       self.class.config
     end
 
+    def logger
+      self.class.logger
+    end
+
     def execute
       catch :exit do
         parse_cli_arguments
@@ -174,19 +182,19 @@ module Kafo
 
     private
 
-    def logger
-      self.class.logger
-    end
-
     def exit(code)
       self.class.exit(code)
     end
 
     def set_parameters
+      # set values based on default_values
       params.each do |param|
-        # set values based on default_values
         param.set_default(config.params_default_values)
-        # set values based on YAML
+      end
+
+      self.class.hooking.execute(:pre_values)
+      # set values based on YAML
+      params.each do |param|
         param.set_value_by_config(config)
       end
     end
@@ -296,7 +304,7 @@ module Kafo
     end
 
     def run_installation
-      self.class.hooking.execute(:pre) if self.class.hooking
+      self.class.hooking.execute(:pre)
       exit_code   = 0
       exit_status = nil
       options     = [
@@ -333,7 +341,7 @@ module Kafo
       @progress_bar.close if @progress_bar
       logger.info "Puppet has finished, bye!"
       FileUtils.rm(temp_config_file, :force => true)
-      self.class.hooking.execute(:post) if self.class.hooking
+      self.class.hooking.execute(:post)
       exit(exit_code)
     end
 

data/lib/kafo/logger.rb

@@ -5,7 +5,11 @@ require 'logging'
 module Kafo
   class Logger
     class << self
-      attr_accessor :loggers
+      attr_writer :loggers
+
+      def loggers
+        @loggers || []
+      end
     end
 
     PATTERN = "[%5l %d %c] %m\n"

data/lib/kafo/params/hash.rb

@@ -25,6 +25,9 @@ module Kafo
           value = [value].flatten
           ::Hash[value.map { |v| v.split(':', 2) }]
         end
+      rescue NoMethodError => e
+        KafoConfigure.logger.warn "Could not typecast #{value} for parameter #{name}, defaulting to {}"
+        return {}
       end
     end
   end

data/lib/kafo/params/integer.rb

@@ -10,6 +10,9 @@ module Kafo
 
       def typecast(value)
         value.nil? ? nil : value.to_i
+      rescue NoMethodError => e
+        KafoConfigure.logger.warn "Could not typecast #{value} for parameter #{name}, defaulting to 0"
+        return 0
       end
     end
   end

data/lib/kafo/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module Kafo
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafo
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Marek Hulan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-11 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -217,6 +217,7 @@ files:
 - lib/kafo/hooking.rb
 - lib/kafo/string_helper.rb
 - lib/kafo/logger.rb
+- lib/kafo/hook_context.rb
 - lib/kafo/color_scheme.rb
 - lib/kafo/param_group.rb
 - lib/kafo/progress_bars/colored.rb