katte 0.0.1.3

data/lib/katte/recipe/node_factory.rb

@@ -0,0 +1,57 @@
+require 'pathname'
+
+module Katte::Recipe
+  class NodeFactory
+    @@after_create_hook = nil
+    def self.after_create(&proc)
+      @@after_create_hook = proc
+    end
+
+    def initialize
+      pattern_regexp = File.join(Katte.app.config.recipes_root, '(?<name>.+?)\.(?<ext>\w+)')
+      @path_pattern = /^#{pattern_regexp}$/
+
+      @nodes = {}
+    end
+
+    def load(path)
+      return unless FileTest.file? path
+      return unless m = @path_pattern.match(path)
+
+      name, ext = m[:name], m[:ext]
+
+      file_type = Katte::Recipe::FileType.find(ext)
+
+      directive = file_type.parse(path)
+
+      requires   = directive['require']
+      output     = directive['output'].map {|o| Katte::Plugins.output[o.first.to_sym]}
+      period     = (directive['period'].empty? ? 'day' : directive['period'].last)
+      options    = Hash[directive['option'].map {|k, v| [k, v || true]}]
+
+      params = {
+        :name         => name,
+        :path         => path,
+        :require      => requires,
+        :file_type    => file_type,
+        :output       => output,
+        :period       => period,
+        :options      => options,
+      }
+
+      if Katte.app.config.mode == 'test'
+        params[:output] = [Katte::Plugins::Output.find(:debug)]
+      end
+
+      create(params)
+    end
+
+    def create(params)
+      node = Katte::Recipe::Node.new params
+
+      @@after_create_hook.call(node, params) if @@after_create_hook
+
+      node
+    end
+  end
+end

data/lib/katte/runner.rb

@@ -0,0 +1,66 @@
+class Katte
+  class Runner
+    require 'katte/runner/callback'
+    include Katte::Runner::Callback
+
+    def run
+      load_nodes
+
+      connect_nodes
+
+      execute
+
+      print_summary
+    end
+
+    def initialize
+    end
+
+    def load_nodes
+      @nodes = Katte::Node::Collection.new
+      (builtin_nodes + recipe_nodes).each {|node| @nodes << node }
+
+      call_after_callbacks(:load_nodes, @nodes)
+    end
+    def builtin_nodes
+      Plugins::Node.plugins.values
+    end
+    def recipe_nodes
+      node_factory = Katte.app.config.factory || Katte::Recipe::NodeFactory.new
+      Find.find(Katte.app.config.recipes_root).select {|file|
+        File.file? file
+      }.map {|file|
+        node_factory.load(file)
+      }
+    end
+
+    def connect_nodes
+      @nodes.connect
+    end
+
+    def execute
+      @summary = Driver.run(@nodes)
+    end
+
+    def print_summary
+      return if Katte.app.config.mode == 'test'
+
+      summray_log_file = File.join(Katte.app.config.log_root, 'summary.log')
+      File.open(summray_log_file, 'w') do |file|
+        file.print <<-EOF
+Summary:
+  success: #{@summary[:success].length}
+  fail:    #{@summary[:fail].length}
+  skip:    #{@summary[:skip].length}
+        EOF
+      end
+
+      failed_log_file = File.join(Katte.app.config.log_root, 'failed.log')
+      File.open(failed_log_file, 'w') do |file|
+        @summary[:fail].each do |node|
+          file.puts node.name
+        end
+      end
+    end
+  end
+end

data/lib/katte/runner/callback.rb

@@ -0,0 +1,36 @@
+module Katte::Runner::Callback
+  module ClassMethods
+    def before(task_name, &proc)
+      before_callbacks[task_name] ||= []
+      before_callbacks[task_name] << proc
+    end
+    def after(task_name, &proc)
+      after_callbacks[task_name] ||= []
+      after_callbacks[task_name] << proc
+    end
+
+    def after_callbacks
+      @after_callbacks ||= {}
+    end
+    def before_callbacks
+      @before_callbacks ||= {}
+    end
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  def call_before_callbacks(task_name, *params)
+    return unless self.class.before_callbacks[task_name]
+    self.class.before_callbacks[task_name].each do |proc|
+      proc.call(*params)
+    end
+  end
+  def call_after_callbacks(task_name, *params)
+    return unless self.class.after_callbacks[task_name]
+    self.class.after_callbacks[task_name].each do |proc|
+      proc.call(*params)
+    end
+  end
+end

data/lib/katte/thread_pool.rb

@@ -0,0 +1,41 @@
+require 'thread'
+
+class Katte
+  class ThreadPool
+    def self.instance
+      @instance ||= new.tap(&:run)
+    end
+
+    attr_reader :threads
+    def initialize(threads_num = 4, logger = Katte.app.logger)
+      @queue         = Queue.new
+      @threads_num   = threads_num
+      @logger        = logger
+    end
+
+    def run
+      procedure = Proc.new {
+        loop {
+          begin
+            @queue.pop.call
+          rescue => e
+            @logger.error(e)
+          end
+        }
+      }
+      @threads ||= @threads_num.times.map { Thread.start &procedure }
+    end
+
+    def push &procedure
+      @queue.push procedure
+    end
+
+    def stop
+      @threads.each &:kill
+    end
+
+    def join
+      @threads.each {|t| t.join}
+    end
+  end
+end

data/lib/katte/version.rb

@@ -0,0 +1,3 @@
+class Katte
+  VERSION = "0.0.1.3"
+end

data/spec/katte/config_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+class Katte
+  describe Config do
+    it "set params to Katte::Config" do
+      config_bak = Katte::Config.config.recipes_root
+
+      config = Class.new(Katte::Config) do |klass|
+        klass.config.recipes_root = 'dummy'
+      end
+
+      expect(Katte::Config.config.recipes_root).to eq 'dummy'
+      Katte::Config.config.recipes_root = config_bak
+    end
+  end
+end

data/spec/katte/driver_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+class Katte
+  describe Driver do
+    it 'excecute each node according to dependency graph' do
+      call_log = []
+      callback = Proc.new {|node| call_log << node.name}
+
+      debug_plugin = Katte::Plugins::FileType::Debug.new
+
+      factory = Katte::Recipe::NodeFactory.new
+      node_collection = Katte::Node::Collection.new
+      node_collection << factory.create(:name      => 'test_1',
+                                        :file_type => debug_plugin,
+                                        :options   => {'callback' => [callback]})
+      node_collection << factory.create(:name      => 'test_2',
+                                        :file_type => debug_plugin,
+                                        :require   => ['test_1'],
+                                        :options   => {'callback' => [callback]})
+      node_collection << factory.create(:name      => 'test_3',
+                                        :file_type => debug_plugin,
+                                        :require   => ['test_2'],
+                                        :options   => {'callback' => [callback]})
+
+      node_collection.connect
+
+      Driver.run(node_collection)
+
+      expect(call_log).to eq %w(test_1 test_2 test_3)
+    end
+
+    it 'skip nodes when parent node failed' do
+      call_log = []
+      callback = Proc.new {|node| call_log << node.name }
+      failure_callback = Proc.new{|node| raise Katte::Plugins::FileType::Debug::Abort}
+      debug_plugin = Katte::Plugins::FileType::Debug.new
+
+      factory = Katte::Recipe::NodeFactory.new
+      node_collection = Katte::Node::Collection.new
+      node_collection << factory.create(:name      =>  'test_1',
+                                        :file_type => debug_plugin,
+                                        :options   => {'callback' => [failure_callback]})
+      node_collection << factory.create(:name      => 'test_2',
+                                        :file_type => debug_plugin,
+                                        :require   => ['test_1'],
+                                        :options   => {'callback' => [callback]})
+      node_collection << factory.create(:name      => 'test_3',
+                                        :file_type => debug_plugin,
+                                        :options   => {'callback' => [callback]})
+                         
+      node_collection.connect
+
+      Driver.run(node_collection)
+
+      expect(call_log).to eq ["test_3"]
+    end
+  end
+end

data/spec/katte/filter_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+class Katte
+  describe Filter do
+    describe ".call" do
+      it "validate date" do
+        filter = Filter.new(datetime: DateTime.parse('2013-01-01'))
+        expect(filter.call(period: 'day')).to be_true
+        expect(filter.call(period: 'week')).to be_false
+        expect(filter.call(period: 'month')).to be_true
+
+        filter = Filter.new(datetime: DateTime.parse('2013-01-07'))
+        expect(filter.call(period: 'day')).to be_true
+        expect(filter.call(period: 'week')).to be_true
+        expect(filter.call(period: 'month')).to be_false
+      end
+    end
+  end
+end

data/spec/katte/node/base_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Katte::Recipe
+  describe Node do
+    describe "#descendants" do
+      it "collect all descendants" do
+        factory = Katte::Recipe::NodeFactory.new
+        node_collection = Katte::Node::Collection.new
+        node_collection << factory.create(name: "a", :require => ["b"])
+        node_collection << factory.create(name: "b", :require => ["c"])
+        node_collection << factory.create(name: "c")
+
+        node_collection.connect
+
+        node_c = node_collection.find("c")
+
+        expect(node_c.descendants.map(&:name)).to eq ["b", "a"]
+      end
+    end
+  end
+end

data/spec/katte/node/collection_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Katte::Node
+  describe Collection do
+    before :all do
+      node_class = Class.new do
+        include Katte::Node::Base
+
+        def initialize(params)
+          @name     = params[:name]
+          @requires = params[:require]
+        end
+        def name; @name; end
+      end
+        
+      @node_collection = Katte::Node::Collection.new
+      @node_collection << node_class.new(name: "a")
+      @node_collection << node_class.new(name: "b")
+      @node_collection << node_class.new(name: "c", require: ["b", "e"])
+      @node_collection << node_class.new(name: "d", require: ["b"])
+
+      @node_collection.connect
+    end
+
+    describe '#connect' do
+      it "ignores unregistered nodes" do
+        expect(@node_collection.find("c").parents.map(&:name)).not_to include "e"
+        expect(@node_collection.find("c").parents).not_to include "e"
+      end
+      it "connect parents and childs" do
+        expect(@node_collection.find("b").children.map(&:name)).to eq %w(c d)
+        expect(@node_collection.find("c").parents.map(&:name)).to eq %w(b)
+      end
+    end
+  end
+end

data/spec/katte/plugins/file_type_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'tempfile'
+
+module Katte::Plugins
+  describe FileType do
+    describe "#simple_exec" do
+      before :all do
+        @file_type_class = Class.new {|klass|
+          include FileType
+        }
+      end
+
+      before(:each) { Katte::Plugins::Output.find(:debug).history.clear }
+      it "execute shell script" do
+        node = Katte::Recipe::Node.new(:name   => 'test/sample',
+                               :path   => File.expand_path('../../../recipes/test/sample.sh', __FILE__),
+                               :output => [Katte::Plugins::Output.find(:debug)])
+
+        file_type = @file_type_class.new
+        file_type.simple_exec(node, 'bash', node.path)
+
+        output = Katte::Plugins::Output.find(:debug).history.pop
+        result = output[:out]
+
+        expect(result).to eq "0\n"
+      end
+    end
+
+    describe '#parse' do
+      before :all do
+        @recipe_path = Tempfile.open('sample_recipe') do |f|
+          f.print <<-EOF
+# require: path/recipe(xxx)
+# option: conf1(p1, p2)
+# option: conf2()
+# option: conf3
+
+echo hello
+          EOF
+          f.path
+        end
+      end
+      after(:all) { File.delete @recipe_path if File.exists? @recipe_path}
+
+      it "parse recipe file" do
+        file_type = Katte::Plugins::FileType::Bash.new
+        directive = file_type.parse(@recipe_path)
+
+        expect(directive).to have_key 'require'
+        expect(directive).to have_key 'option'
+
+        expect(directive['require']).to eq [['path/recipe', ['xxx']]]
+        expect(directive['option']).to  eq [['conf1', ['p1', 'p2']],
+                                            ['conf2', []],
+                                            ['conf3', nil]]
+      end
+    end
+  end
+end

data/spec/katte/plugins/output_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Katte::Plugins
+  describe Output do
+    before :all do
+      klasses = 2.times.map {|i|
+        Class.new {|klass|
+          include Katte::Plugins::Output
+          name :"test_#{i}"
+          attr_reader :result
+          def out(node, data)
+            (@result ||= []) << data
+            data
+          end
+        }
+      }
+      @plugins = klasses.map &:new
+    end
+
+    it "puts to all output plugins" do
+      node = Katte::Recipe::Node.new(output: @plugins)
+      node.open {|out, err|
+        out.puts "a"
+      }
+
+      @plugins.all? {|plugin|
+        expect(plugin.result).to eq ["a\n"]
+      }
+    end
+  end
+end