foreman_hooks 0.1.0 → 0.2.0

data/README.md

@@ -33,9 +33,9 @@ Each file within the directory is executed in alphabetical order.
 
 Examples:
 
+    ~foreman/config/hooks/host/create/50_register_system.sh
+    ~foreman/config/hooks/host/destroy/15_cleanup_database.sh
     ~foreman/config/hooks/smart_proxy/after_create/01_email_operations.sh
-    ~foreman/config/hooks/host/before_provision/50_do_something.sh
-    ~foreman/config/hooks/host/managed/after_destroy/15_cleanup_database.sh
 
 Note that in Foreman 1.1, hosts are just named `Host` so hooks go in a `host/`
 directory, while in Foreman 1.2 they're `Host::Base` and `Host::Managed`, so
@@ -50,7 +50,20 @@ Every object (or model in Rails terms) in Foreman can have hooks.  Check
 * `host/discovered` (Foreman 1.2)
 * `report`
 
-## Events
+## Orchestration events
+
+Foreman supports orchestration tasks for hosts and NICs (each network
+interface) which happen when the object is created, updated and destroyed.
+These tasks are shown to the user in the UI and if they fail, will
+automatically trigger a rollback of the action.
+
+To add hooks to these, use these event names:
+
+* `create`
+* `update`
+* `destroy`
+
+## Rails events
 
 These are the most interesting events that Rails provides and this plugin
 exposes:
@@ -71,9 +84,21 @@ The host object has two special callbacks in Foreman 1.1 that you can use:
 ## Execution of hooks
 
 Hooks are executed in the context of the Foreman server, so usually under the
-`foreman` user.  One argument is provided, which is the string representation
-of the object that was hooked, e.g. the hostname for a host.  No other data
-about the object is currently made available.
+`foreman` user.
+
+The first argument is always the event name, enabling scripts to be symlinked
+into multiple event directories.  The second argument is the string
+representation of the object that was hooked, e.g. the hostname for a host.
+No other data about the object is currently made available.
+
+Every hook within the event directory is executed in alphabetical order.  For
+orchestration hooks, an integer prefix in the hook filename will be used as
+the priority value, so influences where it's done in relation to DNS, DHCP, VM
+creation and other tasks.
+
+If a hook fails (non-zero return code), the event is logged.  
+For orchestration events, a failure will halt the action and rollback will
+occur.  For Rails events, execution of other hooks will continue.
 
 # Copyright
 

data/TODO

@@ -1,3 +1,2 @@
 * pass more data into hooks
   * JSON dump of the model via stdin + utility shell script
-* tie into orchestration

data/foreman_hooks.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = "foreman_hooks"
 
-  s.version = "0.1.0"
-  s.date = "2013-03-23"
+  s.version = "0.2.0"
+  s.date = "2013-03-24"
 
   s.summary = "Run custom hook scripts on Foreman events"
   s.description = "Plugin engine for Foreman that enables running custom hook scripts on Foreman events"

data/lib/foreman_hooks/engine.rb

@@ -1,13 +1,24 @@
 require 'foreman_hooks'
 require 'foreman_hooks/hooks_observer'
+require 'foreman_hooks/orchestration_hook'
 
 module ForemanHooks
   class Engine < ::Rails::Engine
     config.to_prepare do
+      # Register an observer to all classes with hooks present
       ForemanHooks::HooksObserver.observed_classes.each do |klass|
         klass.observers << ForemanHooks::HooksObserver
         klass.instantiate_observers
       end
+
+      # Find any orchestration related hooks and register in those classes
+      ForemanHooks::HooksObserver.hooks.each do |klass,events|
+        orchestrate = false
+        events.keys.each do |event|
+          orchestrate = true if ['create', 'update', 'destroy'].include? event
+        end
+        klass.send(:include, ForemanHooks::OrchestrationHook) if orchestrate
+      end
     end
   end
 end

data/lib/foreman_hooks/hooks_observer.rb

@@ -1,54 +1,8 @@
+require 'foreman_hooks/util'
+
 module ForemanHooks
   class HooksObserver < ActiveRecord::Observer
-    def self.logger
-      Rails.logger
-    end
-
-    def self.hooks_root
-      File.join(Rails.application.root, 'config', 'hooks')
-    end
-
-    # Find all executable hook files under $hook_root/model_name/event_name/
-    def self.search_hooks
-      hooks = {}
-      Dir.glob(File.join(hooks_root, '**', '*')) do |filename|
-        next if filename.end_with? '~'
-        next if filename.end_with? '.bak'
-        next if File.directory? filename
-        next unless File.executable? filename
-
-        relative = filename[hooks_root.size..-1]
-        next unless relative =~ %r{^/(.+)/([^/]+)/([^/]+)$}
-        klass = $1.camelize.constantize
-        event = $2
-        script_name = $3
-        hooks[klass] ||= {}
-        hooks[klass][event] ||= []
-        hooks[klass][event] << filename
-        logger.debug "Found hook to #{klass.to_s}##{event}, filename #{script_name}"
-      end
-      hooks
-    end
-
-    # {ModelClass => {'event_name' => ['/path/to/01.sh', '/path/to/02.sh']}}
-    def self.hooks
-      unless @hooks
-        @hooks = search_hooks
-        @hooks.each do |klass,events|
-          events.each do |event,hooks|
-            logger.info "Finished adding #{hooks.size} hooks to #{Host::Base.to_s}##{event}"
-            hooks.sort!
-          end
-        end
-      end
-      @hooks
-    end
-
-    # ['event1', 'event2']
-    def self.events
-      @events = hooks.values.map(&:keys).flatten.uniq.map(&:to_sym) unless @events
-      @events
-    end
+    include ForemanHooks::Util
 
     # Override ActiveRecord::Observer
     def self.observed_classes
@@ -63,30 +17,12 @@ module ForemanHooks
     def method_missing(event, *args)
       obj = args.first
       logger.debug "Observed #{event} hook on #{obj}"
-
-      return unless hooks = self.class.hooks[obj.class]
-      return unless hooks = hooks[event.to_s]
-      return if hooks.empty?
+      return unless hooks = find_hooks(obj.class, event)
 
       logger.debug "Running #{hooks.size} hooks for #{obj.class.to_s}##{event}"
-      hooks.each { |filename| exec_hook(filename, obj.to_s) }
+      hooks.each { |filename| exec_hook(filename, event.to_s, obj.to_s) }
     end
 
-    def exec_hook(*args)
-      logger.debug "Running hook: #{args.join(' ')}"
-      success = if defined? Bundler && Bundler.responds_to(:with_clean_env)
-                  Bundler.with_clean_env { system(*args) }
-                else
-                  system(*args)
-                end
-
-      unless success
-        logger.warn "Hook failure running `#{args.join(' ')}`: #{$?}"
-      end
-    end
-
-    def logger
-      Rails.logger
-    end
+    def logger; Rails.logger; end
   end
 end

data/lib/foreman_hooks/orchestration_hook.rb

@@ -0,0 +1,63 @@
+require 'foreman_hooks/util'
+
+module ForemanHooks::OrchestrationHook
+  extend ActiveSupport::Concern
+  include ForemanHooks::Util
+
+  included do
+    after_validation :queue_hooks_validate
+    before_destroy :queue_hooks_destroy
+  end
+
+  def queue_hooks_validate
+    return unless errors.empty?
+    queue_hooks(new_record? ? 'create' : 'update')
+  end
+
+  def queue_hooks_destroy
+    return unless errors.empty?
+    queue_hooks('destroy')
+  end
+
+  def queue_hooks(event)
+    logger.debug "Observed #{event} hook on #{self}"
+    unless is_a? Orchestration
+      logger.warn "#{self.class.to_s} doesn't support orchestration, can't run orchestration hooks: use Rails events instead"
+    end
+
+    return unless hooks = find_hooks(self.class, event)
+    logger.debug "Queueing #{hooks.size} hooks for #{self.class.to_s}##{event}"
+
+    counter = 0
+    hooks.each do |filename|
+      basename = File.basename(filename)
+      priority = basename =~ /^(\d+)/ ? $1 : 10000 + (counter += 1)
+      logger.debug "Queuing hook #{basename} for #{self.class.to_s}##{event} at priority #{priority}"
+      queue.create(:name   => "Hook: #{basename}", :priority => priority,
+                   :action => [HookRunner.new(filename, self, event.to_s),
+                               event.to_s == 'destroy' ? :hook_execute_del : :hook_execute_set])
+    end
+  end
+
+  # Orchestration runs methods against an object, so generate a runner for each
+  # hook that will need executing
+  class HookRunner
+    def initialize(filename, obj, event)
+      @filename = filename
+      @obj = obj
+      @event = event
+    end
+
+    def args
+      [@obj.to_s]
+    end
+
+    def hook_execute_set
+      @obj.exec_hook(@filename, @event, *args)
+    end
+
+    def hook_execute_del
+      @obj.exec_hook(@filename, 'destroy', *args)
+    end
+  end
+end

data/lib/foreman_hooks/util.rb

@@ -0,0 +1,76 @@
+module ForemanHooks::Util
+  extend ActiveSupport::Concern
+
+  included do
+    class_eval do
+      def self.hooks_root
+        File.join(Rails.application.root, 'config', 'hooks')
+      end
+
+      # Find all executable hook files under $hook_root/model_name/event_name/
+      def self.discover_hooks
+        hooks = {}
+        Dir.glob(File.join(hooks_root, '**', '*')) do |filename|
+          next if filename.end_with? '~'
+          next if filename.end_with? '.bak'
+          next if File.directory? filename
+          next unless File.executable? filename
+
+          relative = filename[hooks_root.size..-1]
+          next unless relative =~ %r{^/(.+)/([^/]+)/([^/]+)$}
+          klass = $1.camelize.constantize
+          event = $2
+          script_name = $3
+          hooks[klass] ||= {}
+          hooks[klass][event] ||= []
+          hooks[klass][event] << filename
+          logger.debug "Found hook to #{klass.to_s}##{event}, filename #{script_name}"
+        end
+        hooks
+      end
+
+      # {ModelClass => {'event_name' => ['/path/to/01.sh', '/path/to/02.sh']}}
+      def self.hooks
+        unless @hooks
+          @hooks = discover_hooks
+          @hooks.each do |klass,events|
+            events.each do |event,hooks|
+              logger.info "Finished registering #{hooks.size} hooks for #{Host::Base.to_s}##{event}"
+              hooks.sort!
+            end
+          end
+        end
+        @hooks
+      end
+
+      # ['event1', 'event2']
+      def self.events
+        @events = hooks.values.map(&:keys).flatten.uniq.map(&:to_sym) unless @events
+        @events
+      end
+
+      def self.logger; Rails.logger; end
+    end
+  end
+
+  def find_hooks(klass, event)
+    return unless filtered = self.class.hooks[klass]
+    return unless filtered = filtered[event.to_s]
+    return if filtered.empty?
+    filtered
+  end
+
+  def exec_hook(*args)
+    logger.debug "Running hook: #{args.join(' ')}"
+    success = if defined? Bundler && Bundler.responds_to(:with_clean_env)
+                Bundler.with_clean_env { system(*args) }
+              else
+                system(*args)
+              end
+
+    unless success
+      logger.warn "Hook failure running `#{args.join(' ')}`: #{$?}"
+    end
+    success
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_hooks
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-23 00:00:00.000000000 Z
+date: 2013-03-24 00:00:00.000000000 Z
 dependencies: []
 description: Plugin engine for Foreman that enables running custom hook scripts on
   Foreman events
@@ -32,6 +32,8 @@ files:
 - lib/foreman_hooks.rb
 - lib/foreman_hooks/engine.rb
 - lib/foreman_hooks/hooks_observer.rb
+- lib/foreman_hooks/orchestration_hook.rb
+- lib/foreman_hooks/util.rb
 - test/test_helper.rb
 - test/unit/host_observer_test.rb
 homepage: http://github.com/domcleal/foreman_hooks