tengine_core 0.5.28

data/spec/tengine/core/event_wrapper_spec.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'tengine/event'
+
+describe Tengine::Core::EventWrapper do
+  context "[]でpropertiesの属性にアクセス可能" do
+    before do
+      @event = Tengine::Core::Event.create!(
+        :key => Tengine::Event.uuid_gen.generate,
+        :event_type_name => "foo",
+        :sender_name => "server1",
+        :properties => {
+          :foo => [1,2,3,4],
+          :bar => "BAR"
+        })
+      @event.reload
+    end
+
+    subject do
+      Tengine::Core::EventWrapper.new(@event)
+    end
+
+    it do
+      @event.properties['foo'].should == [1,2,3,4]
+      @event.properties[:foo].should == nil
+      subject.properties['foo'].should == [1,2,3,4]
+      subject.properties[:foo].should == nil
+      subject['foo'].should == [1,2,3,4]
+      subject[:foo].should == [1,2,3,4]
+      subject['bar'].should == "BAR"
+      subject[:bar].should == "BAR"
+    end
+  end
+end

data/spec/tengine/core/handler_path_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Tengine::Core::HandlerPath do
+
+  describe :find_handlers do
+    before do
+      Tengine::Core::Driver.delete_all
+      @d11 = Tengine::Core::Driver.find_or_create_by(name:"driver1", version:"1", enabled:true)
+      @d11h1 = @d11.handlers.find_or_create_by(:event_type_names => ["foo" ], :filepath => "path/to/driver1.rb", :lineno => 5)
+      @d11h2 = @d11.handlers.find_or_create_by(:event_type_names => ["boo" ], :filepath => "path/to/driver1.rb", :lineno => 10)
+      @d11h3 = @d11.handlers.find_or_create_by(:event_type_names => ["blah"], :filepath => "path/to/driver1.rb", :lineno => 15)
+      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d11, :handler_id => @d11h1.id)
+      Tengine::Core::HandlerPath.create(:event_type_name => "boo", :driver => @d11, :handler_id => @d11h2.id)
+      Tengine::Core::HandlerPath.create(:event_type_name => "blah", :driver => @d11, :handler_id => @d11h3.id)
+      @d21 = Tengine::Core::Driver.find_or_create_by(name:"driver1", version:"2", enabled:true)
+      @d21h1 = @d21.handlers.find_or_create_by(:event_type_names => ["foo"], :filepath => "path/to/driver1.rb", :lineno => 5)
+      @d21h2 = @d21.handlers.find_or_create_by(:event_type_names => ["boo"], :filepath => "path/to/driver1.rb", :lineno => 12)
+      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d21, :handler_id => @d21h1.id)
+      Tengine::Core::HandlerPath.create(:event_type_name => "boo", :driver => @d21, :handler_id => @d21h2.id)
+      @d22 = Tengine::Core::Driver.find_or_create_by(name:"driver2", version:"2", enabled:true)
+      @d22h1 = @d22.handlers.find_or_create_by(:event_type_names => ["foo"], :filepath => "path/to/driver2.rb", :lineno => 20)
+      @d22h2 = @d22.handlers.find_or_create_by(:event_type_names => ["bar"], :filepath => "path/to/driver2.rb", :lineno => 30)
+      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d22, :handler_id => @d22h1.id)
+      Tengine::Core::HandlerPath.create(:event_type_name => "bar", :driver => @d22, :handler_id => @d22h2.id)
+      @d23 = Tengine::Core::Driver.find_or_create_by(name:"driver3", version:"2", enabled:false)
+      @d23h1 = @d23.handlers.find_or_create_by(:event_type_names => ["bar"], :filepath => "path/to/driver3.rb", :lineno => 2)
+      @d23h2 = @d23.handlers.find_or_create_by(:event_type_names => ["baz"], :filepath => "path/to/driver3.rb", :lineno => 10)
+      Tengine::Core::HandlerPath.create(:event_type_name => "bar", :driver => @d23, :handler_id => @d23h1.id)
+      Tengine::Core::HandlerPath.create(:event_type_name => "baz", :driver => @d23, :handler_id => @d23h2.id)
+    end
+
+    context "with default_driver_version" do
+      it "should return handlers" do
+        Tengine::Core::HandlerPath.default_driver_version = "2"
+        Tengine::Core::HandlerPath.find_handlers("foo").map(&:id).should == [@d21h1.id, @d22h1.id]
+        Tengine::Core::HandlerPath.find_handlers("boo").map(&:id).should == [@d21h2.id]
+        Tengine::Core::HandlerPath.find_handlers("bar").map(&:id).should == [@d22h2.id]
+        Tengine::Core::HandlerPath.find_handlers("baz").map(&:id).should == []
+        Tengine::Core::HandlerPath.find_handlers("FOO").map(&:id).should == []
+        Tengine::Core::HandlerPath.find_handlers("blah").map(&:id).should == []
+      end
+
+      it "should return old handlers" do
+        Tengine::Core::HandlerPath.default_driver_version = "1"
+        Tengine::Core::HandlerPath.find_handlers("foo").map(&:id).should == [@d11h1.id]
+        Tengine::Core::HandlerPath.find_handlers("boo").map(&:id).should == [@d11h2.id]
+        Tengine::Core::HandlerPath.find_handlers("blah").map(&:id).should == [@d11h3.id]
+        Tengine::Core::HandlerPath.find_handlers("bar").map(&:id).should == []
+        Tengine::Core::HandlerPath.find_handlers("baz").map(&:id).should == []
+      end
+    end
+
+    context "generated handler_paths" do
+      before do
+        Tengine::Core::Driver.delete_all
+        Tengine::Core::HandlerPath.delete_all
+      end
+
+      it "should return handlers for enabled driver" do
+        @driver = Tengine::Core::Driver.new(:name => "driver01", :version => "123", :enabled => true)
+        @handler1 = @driver.handlers.new(:event_type_names => ["event01"],
+          :filepath => "path/to/driver01.rb", :lineno => 8)
+        @driver.save!
+
+        Tengine::Core::HandlerPath.all.count.should == 1
+        Tengine::Core::HandlerPath.default_driver_version = "123"
+        handlers = Tengine::Core::HandlerPath.find_handlers("event01")
+        handlers.count.should == 1
+        handlers.each do |handler|
+          handler.id.should == @handler1.id
+        end
+      end
+
+      it "should return handlers for disabled driver" do
+        @driver = Tengine::Core::Driver.new(:name => "driver01", :version => "123", :enabled => false)
+        @handler1 = @driver.handlers.new(:event_type_names => ["event01"],
+          :filepath => "path/to/driver01.rb", :lineno => 8)
+        @driver.save!
+
+        Tengine::Core::HandlerPath.all.count.should == 1
+        Tengine::Core::HandlerPath.default_driver_version = "123"
+        Tengine::Core::HandlerPath.find_handlers("event01").count.should == 0
+      end
+    end
+  end
+
+end

data/spec/tengine/core/handler_spec.rb

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Tengine::Core::Handler do
+  valid_attributes1 = {
+    :filepath => "path/to/driver.rb",
+    :lineno => 100,
+  }.freeze
+
+  context "filepathとlinenoは必須" do
+    it "正常系" do
+      driver1 = Tengine::Core::Handler.new(valid_attributes1)
+      driver1.valid?.should == true
+    end
+
+    [:filepath, :lineno].each do |key|
+      it "#{key}なし" do
+        attrs = valid_attributes1.dup
+        attrs.delete(key)
+        driver1 = Tengine::Core::Handler.new(attrs)
+        driver1.valid?.should == false
+      end
+    end
+  end
+
+#   context :process_event do
+#     before do
+#       @driver = Tengine::Core::Driver.new
+#       @handler = Tengine::Core::Handler.new(:driver => @driver)
+#     end
+
+#     it "マッチするかどうかと関係なくブロックが呼び出されます" do
+#       mock_dsl_context = mock(:dsl_context)
+#       mock_kernel = mock(:kernel)
+#       mock_event = mock(:event)
+#       mock_caller = mock(:caller)
+#       mock_block = nil
+#       mock_caller.instance_eval do
+#         mock_block = lambda{}
+#       end
+#       mock_event.stub(:kernel).and_return(mock_kernel)
+#       mock_kernel.stub(:dsl_context).and_return(mock_dsl_context)
+#       mock_dsl_context.stub(:__block_for__).and_return(mock_block)
+#       # @handler.should_receive(:instance_eval).with(&mock_block)
+#       mock_caller.should_receive(:__safety_driver__).and_yield
+#       mock_caller.should_receive(:__safety_event__).and_yield
+#       mock_caller.should_receive(:instance_eval)
+#       @handler.process_event(mock_event, &mock_block)
+#     end
+#   end
+
+  describe :match? do
+    context "without session" do
+      # it "by source_name"
+      # it "by sender_name"
+      # it "by occurred_at"
+    end
+
+    context "with session" do
+      context "foo & bar" do
+        before do
+          Tengine::Core::Driver.delete_all
+          Tengine::Core::Session.delete_all
+          @driver1 = Tengine::Core::Driver.new(:name => "driver1", :version => "123")
+          @handler = @driver1.handlers.new(:event_type_names => [:foo, :bar],
+            :filepath => "path/to/driver.rb",
+            :lineno => 11,
+            :filter => {
+              'method' => :and,
+              'children' => [
+                { 'pattern' => 'foo', 'method' => :find_or_mark_in_session },
+                { 'pattern' => 'bar', 'method' => :find_or_mark_in_session },
+              ]
+            })
+          @driver1.save!
+          @handler
+        end
+        subject{ @handler }
+
+        it "最初にfooが受信したらセッションに記録してfalse" do
+          event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
+          subject.match?(event_foo).should == false
+          @driver1.session.system_properties.should == {'mark_foo' => true}
+        end
+
+        it "最初にbarが受信したらセッションに記録してfalse" do
+          # 実装がall?などを使って全てのフィルタを評価しない場合は失敗することがあります。
+          event_bar = FactoryGirl.create(:"tengine/core/event", :event_type_name => "bar")
+          subject.match?(event_bar).should == false
+          @driver1.session.system_properties.should == {'mark_bar' => true}
+        end
+
+        context "一度fooを受信した場合" do
+          before do
+            session = @driver1.session
+            session.system_properties = {'mark_foo' => true}
+            session.save!
+          end
+
+          it "再度fooが来るとセッションは変更なくfalse" do
+            event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
+            subject.match?(event_foo).should == false
+            @driver1.reload
+            @driver1.session.system_properties.should == {'mark_foo' => true}
+          end
+
+          it "barが来るとセッションを変更してtrue" do
+            event_bar = FactoryGirl.create(:"tengine/core/event", :event_type_name => "bar")
+            subject.match?(event_bar).should == true
+            @driver1.reload
+            @driver1.session.system_properties.should == {'mark_foo' => true, 'mark_bar' => true}
+          end
+        end
+
+        context "一度barを受信した場合" do
+          before do
+            session = @driver1.session
+            session.system_properties = {'mark_bar' => true}
+            session.save!
+          end
+
+          it "fooが来るとセッションを変更してtrue" do
+            event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
+            subject.match?(event_foo).should == true
+            @driver1.reload
+            @driver1.session.system_properties.should == {'mark_foo' => true, 'mark_bar' => true}
+          end
+        end
+
+
+      end
+
+    end
+
+  end
+
+
+  describe 'filter persistence' do
+    before do
+      Tengine::Core::Driver.delete_all
+      @driver1 = Tengine::Core::Driver.new(:name => "driver1", :version => "123")
+    end
+
+    it "デフォルトでは空のHash" do
+      @driver1.handlers.new(:event_type_names => [:foo, :bar],
+        :filepath => "path/to/driver.rb", :lineno => 8)
+      @driver1.save!
+      loaded = Tengine::Core::Driver.find(@driver1.id)
+      handler1 = loaded.handlers.first
+      handler1.filter.should == {}
+    end
+
+    it "はネストしたフィルタの情報を保持できる" do
+      expected_hash = {
+          :method => :or,
+          :children => [
+            {
+              :method => :and,
+              :children => [
+                { :pattern => 'foo', :method => :find_or_mark_in_session },
+                { :pattern => 'bar', :method => :find_or_mark_in_session },
+              ]
+            },
+            { :method => :equal, :pattern => "baz"}
+          ]
+        }
+      @driver1.handlers.new(:event_type_names => [:foo, :bar],
+        :filepath => "path/to/driver.rb", :lineno => 8,
+        :filter => expected_hash)
+      @driver1.save!
+      loaded = Tengine::Core::Driver.find(@driver1.id)
+      handler1 = loaded.handlers.first
+      # mongoの制約でSymbolのキーは文字列に変換される。
+      handler1.filter.should == {
+          'method' => :or,
+          'children' => [
+            {
+              'method' => :and,
+              'children' => [
+                { 'pattern' => 'foo', 'method' => :find_or_mark_in_session },
+                { 'pattern' => 'bar', 'method' => :find_or_mark_in_session },
+              ]
+            },
+            { 'method' => :equal, 'pattern' => "baz"}
+          ]
+        }
+    end
+  end
+
+end

data/spec/tengine/core/heartbeat_watcher_spec.rb

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'amqp'
+
+require_relative '../../../lib/tengine/core/heartbeat_watcher'
+require 'tengine/mq/suite'
+
+describe Tengine::Core::HeartbeatWatcher do
+  before do
+    Tengine::Core::Event.delete_all
+    @uuid = UUID.new
+  end
+
+  subject do
+    Tengine::Core::HeartbeatWatcher.new(%w[--heartbeat-hbw-interval=30])
+  end
+
+  describe "#search_for_invalid_heartbeat" do
+
+    before do
+      @fixtures = Array.new
+      @fixtures << Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.second.ago)
+      @fixtures.each {|i| i.save! }
+    end
+
+    it "古いものを検索してくる" do
+      set = []
+      EM.run do
+        subject.search_for_invalid_heartbeat do |i|
+          set << i
+        end
+        EM.add_timer 0.1 do EM.stop end
+      end
+
+      set.should include(@fixtures[0])
+      set.should_not include(@fixtures[1])
+    end
+  end
+
+  describe "#search_for_invalid_heartbeat, kind_of" do
+
+    before do
+      @fixtures = Array.new
+      @fixtures << Tengine::Core::Event.new(key: "job1", event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "job2", event_type_name: "job.heartbeat.tengine", occurred_at: 1.second.ago)
+      @fixtures << Tengine::Core::Event.new(key: "cor1", event_type_name: "core.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "cor2", event_type_name: "core.heartbeat.tengine", occurred_at: 10.second.ago)
+      @fixtures << Tengine::Core::Event.new(key: "hbw1", event_type_name: "hbw.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "hbw2", event_type_name: "hbw.heartbeat.tengine", occurred_at: 1.second.ago)
+      @fixtures << Tengine::Core::Event.new(key: "rsw1", event_type_name: "resourcew.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "rsw2", event_type_name: "resourcew.heartbeat.tengine", occurred_at: 10.second.ago)
+      @fixtures << Tengine::Core::Event.new(key: "atd1", event_type_name: "atd.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "atd2", event_type_name: "atd.heartbeat.tengine", occurred_at: 10.second.ago)
+      @fixtures << Tengine::Core::Event.new(key: "hog1", event_type_name: "hoge.heartbeat.tengine", occurred_at: 1.day.ago)
+      @fixtures << Tengine::Core::Event.new(key: "hog2", event_type_name: "hoge.heartbeat.tengine", occurred_at: 10.second.ago)
+      @fixtures.each {|i| i.save! }
+    end
+
+    it "古い job,core,hbw,resourcew,atd を検索してくる" do
+      EM.run do
+        subject.search_for_invalid_heartbeat do |i|
+          (i.key =~ /job1|cor1|hbw1|rsw1|atd1/).should be_true
+          (i.key =~ /job2|cor2|hbw2|rsw2|atd2|hog1|hog2/).should be_false
+        end
+        EM.add_timer 0.1 do EM.stop end
+      end
+    end
+  end
+
+  describe "#send_last_event" do
+    it "finished.process.hbw.tengineの発火" do
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with("finished.process.hbw.tengine", an_instance_of(Hash))
+      sender.should_receive(:stop)
+      subject.send_last_event
+    end
+  end
+
+  describe "#send_periodic_event" do
+    it "hbw.heartbeat.tengineの発火" do
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with("hbw.heartbeat.tengine", an_instance_of(Hash))
+      sender.stub(:fire).with("finished.process.hbw.tengine", an_instance_of(Hash)) # 来るかも
+      subject.send_periodic_event
+    end
+  end
+
+  describe "#send_invalidate_event" do
+    it "引数のイベントのtypeを書き換えて、他は同じで発火" do
+      e0 = Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with(an_instance_of(Tengine::Event), an_instance_of(Hash)) do |e1, h|
+        e1.event_type_name.should == "foobar"
+        e1.occurred_at.should == e0.occurred_at
+        e1.key.should == e0.key
+      end
+
+      subject.send_invalidate_event "foobar", e0
+    end
+  end
+
+  describe "#sender" do
+    before do
+      conn = mock(:connection)
+      conn.stub(:on_tcp_connection_loss)
+      conn.stub(:after_recovery)
+      conn.stub(:on_closed)
+      AMQP.stub(:connect).with(an_instance_of(Hash)).and_return(conn)
+    end
+    subject { Tengine::Core::HeartbeatWatcher.new([]).sender }
+    it { should be_kind_of(Tengine::Event::Sender) }
+  end
+
+  describe "#run" do
+    it "各種timerを登録する" do
+      EM.stub(:run).and_yield
+      Daemons.stub(:run_proc).with(anything, anything).and_yield
+      EM.should_receive(:add_periodic_timer).exactly(2).times
+      Tengine::Core::MethodTraceable.stub(:disabled=)
+      sender = mock(:sender)
+      sender.stub(:wait_for_connection).and_yield
+      subject.stub(:sender).and_return(sender)
+      subject.instance_eval { @config }.stub(:setup_loggers)
+      subject.run __FILE__
+    end
+  end
+end

data/spec/tengine/core/io_to_logger_spec.rb

@@ -0,0 +1,30 @@
+
+
+
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'stringio'
+
+describe Tengine::Core::IoToLogger do
+
+  context "redirect from io to logger" do
+    before do
+      @io = StringIO.new
+      @logger = Logger.new(@io)
+      @logger.level = Logger::INFO
+    end
+    subject{ Tengine::Core::IoToLogger.new(@logger) }
+    it "should provide puts method" do
+      subject.puts("foo")
+      @io.rewind
+      @io.readlines.should == ["foo\n"]
+    end
+    it "should provide write method" do
+      subject.write("foo")
+      @io.rewind
+      @io.readlines.should == ["foo\n"]
+    end
+  end
+
+end