foreman_hooks 0.3.1 → 0.3.2

data/foreman_hooks.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = "foreman_hooks"
 
-  s.version = "0.3.1"
-  s.date = "2013-04-07"
+  s.version = "0.3.2"
+  s.date = "2013-05-30"
 
   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.rb

@@ -1,3 +1,88 @@
 module ForemanHooks
   require 'foreman_hooks/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'foreman_hooks/util'
+  require 'foreman_hooks/callback_hooks'
+  require 'foreman_hooks/orchestration_hook'
+
+  class << self
+    def hooks_root
+      File.join(Rails.application.root, 'config', 'hooks')
+    end
+
+    # Find all executable hook files under $hook_root/model_name/event_name/
+    def 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
+        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 hooks
+      unless @hooks
+        @hooks = discover_hooks
+        @hooks.each do |klass,events|
+          events.each do |event,hooks|
+            logger.info "Finished registering #{hooks.size} hooks for #{klass}##{event}"
+            hooks.sort!
+          end
+        end
+      end
+      @hooks
+    end
+
+    # ['event1', 'event2']
+    def events(klass = nil)
+      filtered = if klass
+                   klass = klass.name if klass.kind_of? Class
+                   Hash[hooks.select { |k,e| k == klass }]
+                 else
+                   hooks
+                 end
+      @events = filtered.values.map(&:keys).flatten.uniq.map(&:to_sym) unless @events
+      @events
+    end
+
+    def find_hooks(klass, event)
+      klass = klass.name if klass.kind_of? Class
+      return unless filtered = hooks[klass]
+      return unless filtered = filtered[event.to_s]
+      return if filtered.empty?
+      filtered
+    end
+
+    def logger; Rails.logger; end
+  end
+end
+
+module ActiveSupport::Dependencies
+  class << self
+    def load_missing_constant_with_hooks(from_mod, constant_name)
+      ret = load_missing_constant_without_hooks(from_mod, constant_name)
+      ForemanHooks.hooks.each do |klass,events|
+        next unless ret.name == klass
+        if events.keys.detect { |event| ['create', 'update', 'destroy'].include? event }
+          ret.send(:include, ForemanHooks::OrchestrationHook) unless ret.ancestors.include?(ForemanHooks::OrchestrationHook)
+        end
+        ret.send(:include, ForemanHooks::CallbackHooks) unless ret.ancestors.include?(ForemanHooks::CallbackHooks)
+      end
+      ret
+    end
+
+    alias_method_chain :load_missing_constant, :hooks
+  end
 end

data/lib/foreman_hooks/callback_hooks.rb

@@ -0,0 +1,22 @@
+require 'foreman_hooks/util'
+
+module ForemanHooks::CallbackHooks
+  extend ActiveSupport::Concern
+  include ForemanHooks::Util
+
+  included do
+    ForemanHooks.events(self).each do |event|
+      filter, name = event.to_s.split('_', 2)
+      next unless name
+
+      set_callback name, "#{event}_hooks"
+      define_method("#{event}_hooks") do
+        Rails.logger.debug "Observed #{event} hook on #{self}"
+        return unless hooks = ForemanHooks.find_hooks(self.class, event)
+
+        Rails.logger.debug "Running #{hooks.size} hooks for #{self.class.to_s}##{event}"
+        hooks.each { |filename| exec_hook(filename, event.to_s, to_s) }
+      end
+    end
+  end
+end

data/lib/foreman_hooks/engine.rb

@@ -1,21 +1,6 @@
 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 = events.keys.detect { |event| ['create', 'update', 'destroy'].include? event }
-        klass.send(:include, ForemanHooks::OrchestrationHook) if orchestrate
-      end
-    end
   end
 end

data/lib/foreman_hooks/orchestration_hook.rb

@@ -25,7 +25,7 @@ module ForemanHooks::OrchestrationHook
       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)
+    return unless hooks = ForemanHooks.find_hooks(self.class, event)
     logger.debug "Queueing #{hooks.size} hooks for #{self.class.to_s}##{event}"
 
     counter = 0
@@ -33,7 +33,7 @@ module ForemanHooks::OrchestrationHook
       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,
+      queue.create(:name   => "Hook: #{basename}", :priority => priority.to_i,
                    :action => [HookRunner.new(filename, self, event.to_s),
                                event.to_s == 'destroy' ? :hook_execute_del : :hook_execute_set])
     end

data/lib/foreman_hooks/util.rb

@@ -3,65 +3,6 @@ require 'open3'
 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 #{klass.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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_hooks
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-07 00:00:00.000000000 Z
+date: 2013-05-30 00:00:00.000000000 Z
 dependencies: []
 description: Plugin engine for Foreman that enables running custom hook scripts on
   Foreman events
@@ -32,8 +32,8 @@ files:
 - examples/log.sh
 - foreman_hooks.gemspec
 - lib/foreman_hooks.rb
+- lib/foreman_hooks/callback_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

data/lib/foreman_hooks/hooks_observer.rb

@@ -1,28 +0,0 @@
-require 'foreman_hooks/util'
-
-module ForemanHooks
-  class HooksObserver < ActiveRecord::Observer
-    include ForemanHooks::Util
-
-    # Override ActiveRecord::Observer
-    def self.observed_classes
-      hooks.keys
-    end
-
-    def respond_to?(method)
-      return true if super
-      self.class.events.include? method
-    end
-
-    def method_missing(event, *args)
-      obj = args.first
-      logger.debug "Observed #{event} hook on #{obj}"
-      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, event.to_s, obj.to_s) }
-    end
-
-    def logger; Rails.logger; end
-  end
-end