flydata 0.3.24 → 0.4.0

data/spec/flydata/helper/action_ownership_channel_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'flydata/helper/action_ownership_channel'
+require 'timecop'
+
+module Flydata
+  module Helper
+    describe ActionOwnershipChannel do
+      let(:channel) { described_class.new }
+      let(:action_info) do
+        { id: 101, config: %Q|{"num_of_lines" : "10"}| }
+      end
+
+      describe '#request_action' do
+        let(:action_name) { :send_logs }
+        subject { channel.request_action(action_name, action_info) }
+
+        context "when action is valid" do
+          it "should return true and also add the action to the queue" do
+            expect(channel.instance_variable_get(:@queue)).to be_empty
+            is_expected.to be(true)
+            expect(channel.instance_variable_get(:@queue).size).to be(1)
+          end
+        end
+
+        context "when action is not valid" do
+          let(:action_name) { :start_agent }
+          it "should raise an error" do
+            expect {subject}.to raise_error('Received invalid action request:start_agent')
+          end
+        end
+
+        context "when the queue already contains the action" do
+          before do
+            channel.request_action(action_name, action_info)
+          end
+          it "should not alter the queue and return false" do
+            expect(channel.instance_variable_get(:@queue).size).to be(1)
+            is_expected.to be(false)
+            expect(channel.instance_variable_get(:@queue).size).to be(1)
+          end
+        end
+      end
+
+      describe '#take_action_ownership' do
+        let(:new_owner) { 'new-owner' }
+        subject { channel.take_action_ownership(new_owner)}
+
+        context "when the queue is empty" do
+          it "should return nil" do
+            is_expected.to be_nil
+          end
+        end
+
+        context "when the action is being processed" do
+          before do
+            channel.request_action(:send_logs, action_info)
+            channel.take_action_ownership("another-owner")
+            channel.request_action(:send_logs, action_info)
+          end
+          it "should return nil" do
+            is_expected.to be_nil
+          end
+        end
+
+        context "when the action needs to be taken exclusively  \
+                        and there are other exclusive actions in progress" do
+           before do
+            channel.request_action(:stop_agent)
+            channel.take_action_ownership("another-owner")
+            channel.request_action(:restart_agent)
+           end
+           it "should return nil" do
+            is_expected.to be_nil
+           end
+        end
+
+        context "when the action can be taken" do
+          before do
+            channel.request_action(:send_logs, action_info)
+          end
+          it "should remove the action from the queue and return" do
+            expect(channel.instance_variable_get(:@queue).size).to be(1)
+            action = channel.take_action_ownership(new_owner)
+            expect(channel.instance_variable_get(:@queue).size).to be(0)
+            expect(action[:action_ownership].action_name).to be(:send_logs)
+            expect(action[:action_ownership].owner).to be(new_owner)
+            expect(action[:action_info]).to eq(action_info)
+          end
+        end
+      end
+
+      describe '#return_action_ownership' do
+        before do
+          channel.request_action(:restart_agent)
+          @action_ownership = channel.take_action_ownership('test-owner')[:action_ownership]
+          Timecop.freeze(Time.local(2014, 8, 19, 16, 11, 24))
+        end
+
+        after do
+          Timecop.return
+        end
+
+        it 'update action_ownership' do
+          channel.return_action_ownership(@action_ownership)
+          expect(@action_ownership.owner).to be_nil
+          expect(@action_ownership.last_processed_time).
+            to eq(Time.local(2014, 8, 19, 16, 11, 24).to_f)
+        end
+      end
+    end
+  end
+end    

data/spec/flydata/helper/action_ownership_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'flydata/helper/action_ownership'
+
+module Flydata
+  module Helper
+    describe ActionOwnership do
+      describe '#initialize' do
+        let(:action_name) { 'stop_agent' }
+        let(:action_class) { Action::StopAgent }
+
+        subject { described_class.new(action_name, true, action_class) }
+
+        it { expect(subject.action_name).to eq(action_name) }
+        it { expect(subject.resource_change).to eq(true) }
+        it { expect(subject.action_class).to eq(action_class) }
+        it { expect(subject.owner).to eq(nil) }
+        it { expect(subject.last_processed_time).to eq(-1) }
+      end
+
+      describe '#processing?' do
+        let(:action_name) { 'stop_agent' }
+        let(:action_class) { Action::StopAgent }
+        let(:ownership) { described_class.new(action_name, true, action_class) }
+
+        subject { ownership.processing? }
+
+        context 'when owner is not set' do
+          it { expect(subject).to be(false) }
+        end
+        context 'when owner is set' do
+          before { ownership.owner = 'test-owner' }
+          it { expect(subject).to be(true) }
+        end
+      end
+
+      describe '.action_ownership_map' do
+        subject { described_class.action_ownership_map }
+        it do
+          expect(subject.size).to eq(4)
+          expect(subject.include?(:check_remote_actions)).to be(true)
+          expect(subject.include?(:send_logs)).to be(true)
+          expect(subject.include?(:stop_agent)).to be(true)
+          expect(subject.include?(:restart_agent)).to be(true)
+        end
+      end
+    end
+  end
+end    

data/spec/flydata/helper/config_parser_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'flydata/helper/config_parser'
+
+module Flydata
+  module Helper
+    describe Config do
+      context ".create" do
+        subject { Config.create(config_hash) }
+        context "initialized with empty hash" do
+          let(:config_hash) { Hash.new }
+          it "should return a config object and respond to dynamically added methods" do
+            is_expected.not_to be_nil
+            is_expected.to respond_to(:helper_home)
+          end
+          it "should return default values correctly" do
+            expect(subject.helper_retry_limit).to eq(15)
+          end
+        end
+        context "initialized with non-empty hash" do
+          let(:override_helper_home) { "/home/user/.flydata/helper" }
+          let(:config_hash) { {helper_home: override_helper_home} }
+          it "should return correct value of a property" do
+            expect(subject.helper_home).to eq(override_helper_home)
+          end
+        end
+      end
+
+      context '#scheduled_actions' do
+        subject { Config.default }
+        it "should return the scheduled actions correctly" do
+          expect(subject.scheduled_actions).to eq({
+            check_remote_actions:
+              {
+                check_interval: 30,
+                name: :check_remote_actions
+              }
+          })
+        end
+        it "should return a copy everytime" do
+          helper_config = subject
+          src = helper_config[:scheduled_actions]
+          copy = helper_config.scheduled_actions
+          expect(src.object_id).not_to eq(copy.object_id)
+          expect(src[:check_remote_actions].object_id).
+            not_to eq(copy[:check_remote_actions].object_id)
+        end
+      end
+    end
+
+    describe ConfigParser do
+      context ".parse" do
+        subject { described_class.parse(conf_content)}
+        context "when the parsed content is empty" do
+          let(:conf_content) { "" }
+          it "should raise an error" do
+            expect { subject }.to raise_error
+          end
+        end
+        context "when the parsed content does not contain scheduled action" do
+          let(:conf_content) { "workers: 5" }
+          it "should return the default scheduled action" do
+            is_expected.to eq({
+              workers: 5,
+              helper: {
+                scheduled_actions: {
+                  check_remote_actions: {
+                    check_interval: '30s'
+                  }
+                }
+              }
+            })
+          end
+        end
+        context "when content includes scheduled action" do
+          let(:conf_content) { <<EOT
+workers: 2
+helper:
+  scheduled_actions:
+    check_remote_actions:
+      check_interval: 1m
+EOT
+          }
+          it "should parse to a Config object" do
+            is_expected.to eq({
+              workers: 2,
+              helper: {
+                scheduled_actions: {
+                  check_remote_actions: {
+                    check_interval: '1m'
+                  }
+                }
+              }
+            })
+          end
+        end
+      end
+    end
+  end
+end    

data/spec/flydata/helper/helper_shared_context.rb

@@ -0,0 +1,70 @@
+module Flydata
+  module Helper
+    shared_context 'helper context' do
+      let(:action_object) { double("action_object") }
+
+      let(:action_class) do
+        c = double("action_class")
+        allow(c).to receive(:new).and_return(action_object)
+        c
+      end
+
+      let(:action_ownership) do
+        o = double("action_ownership")
+        allow(o).to receive(:action_name).and_return(:check_remote_actions)
+        allow(o).to receive(:action_class).and_return(action_class)
+        o
+      end
+
+      let(:action) do
+        a = double("action")
+        allow(a).to receive(:[]).with(:action_ownership).and_return(action_ownership)
+        allow(a).to receive(:[]).with(:action_info).and_return(nil)
+        a
+      end
+
+      let(:action_ownership_channel) { double("action_ownership_channel") }
+
+      let(:logger) do
+        l = double("logger")
+        [:fatal, :error, :warn, :info, :debug]. each do |level|
+          allow(l).to receive(level)
+        end
+        l
+      end
+
+      let(:server) do
+        s = double("server")
+        allow(s).to receive(:logger).and_return(logger)
+        allow(s).to receive(:action_ownership_channel).
+          and_return(action_ownership_channel)
+        allow(s).to receive(:config).
+          and_return(config)
+        s
+      end
+
+      let(:scheduled_actions) do
+        {
+          check_remote_actions: {
+            check_interval: 1
+          }
+        }
+      end
+
+      let(:helper_conf) do
+        c = double("helper_conf")
+        allow(c).to receive(:helper_retry_limit).and_return(10)
+        allow(c).to receive(:helper_retry_interval).and_return(0.1)
+        allow(c).to receive(:helper_action_position_path).and_return("some_path")
+        c
+      end
+
+      let(:config) do
+        h = double("config")
+        allow(h).to receive(:scheduled_actions).and_return(scheduled_actions)
+        allow(h).to receive(:[]).with(:helper).and_return(helper_conf)
+        h
+      end
+    end
+  end
+end  

data/spec/flydata/helper/scheduler_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'flydata/helper/scheduler'
+require_relative 'helper_shared_context'
+
+module Flydata
+  module Helper
+    describe Scheduler do
+      include_context 'helper context'
+      let(:scheduler) do
+        described_class.new(config, server)
+      end
+
+      describe 'start and stop scheduler' do
+        it 'requests check_remote_actions once' do
+          expect(action_ownership_channel).to receive(:request_action).with(:check_remote_actions).once
+          scheduler.start
+          sleep 0.5 #Wait for start
+          scheduler.shutdown
+          expect(scheduler.running?).to be_falsey
+        end
+      end
+
+      describe 'start and wait for one full loop' do
+        it 'requests check_remote_actions twice' do
+          expect(action_ownership_channel).to receive(:request_action).with(:check_remote_actions).twice
+          scheduler.start
+          sleep 1.5 #Added 0.5s delta
+          scheduler.shutdown
+          expect(scheduler.running?).to be_falsey
+        end
+      end
+
+    end
+  end
+end  

data/spec/flydata/helper/worker_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'flydata/helper/worker'
+require_relative 'helper_shared_context'
+
+module Flydata
+  module Helper
+    describe Worker do
+      include_context 'helper context'
+
+      let(:worker_id) { 1 }
+
+      let(:worker) do
+        w = ServerEngine::Worker.new(server, worker_id)
+        w.extend(ServerEngine::Server::WorkerInitializer)
+        w.extend(Worker)
+        w.instance_eval { initialize }
+        w
+      end
+
+      def start_and_wait_worker
+        @thread = Thread.new { worker.run }
+        sleep 0.5
+      end
+
+      def wait_for_one_run_loop; sleep 1; end
+
+      def shutdown_worker
+        if @thread
+          worker.stop
+          @thread.join
+          @thread = nil
+        end
+      end
+
+      describe "#run" do
+        after do
+          shutdown_worker
+        end
+
+        it 'is running' do
+          allow(action_ownership_channel).to receive(:take_action_ownership).and_return(nil)
+          start_and_wait_worker
+          expect(@thread.alive?).to be(true)
+        end
+
+        context 'when request an action' do
+          before do
+            allow(action_ownership_channel).to receive(:take_action_ownership).and_return(action, nil)
+            expect(action_ownership_channel).to receive(:return_action_ownership).with(action_ownership).once
+          end
+
+          context 'when action does not yield' do
+            it 'takes and executes the action' do
+              expect(action_object).to receive(:execute).once
+              expect(action_ownership).to receive(:reset_retry_count)
+              start_and_wait_worker
+              wait_for_one_run_loop
+            end
+          end
+          context 'when action yields' do
+            it 'requests a new action' do
+              expect(action_object).to receive(:execute).once.and_yield(:send_logs, nil)
+              expect(action_ownership_channel).to receive(:request_action).with(:send_logs, nil)
+              expect(action_ownership).to receive(:reset_retry_count)
+              start_and_wait_worker
+            end
+          end
+
+          context 'when action raises error' do
+            before do
+              expect(action_object).to receive(:execute).once.and_raise("test error")
+            end
+
+            it 'retries by creating a action request if it has NOT hit the retry limit' do
+              expect(action_ownership).to receive(:increment_retry_count).and_return(1)
+              expect(action_ownership_channel).
+                to receive(:request_action).with(:check_remote_actions, nil).once
+              start_and_wait_worker
+            end
+
+            it 'does not retry the action request if it has hit the retry limit' do
+              expect(action_ownership).to receive(:increment_retry_count).and_return(10)
+              expect(action_ownership).to receive(:reset_retry_count)
+              start_and_wait_worker
+            end
+          end
+        end
+      end
+
+      describe "#reload" do
+        before do
+          allow(action_ownership_channel).to receive(:take_action_ownership).and_return(nil)
+          start_and_wait_worker
+        end
+
+        after { shutdown_worker }
+        it 'stop worker' do
+          expect(@thread.alive?).to be_truthy
+          worker.reload
+          sleep 0.5 #wait to stop
+          expect(@thread.alive?).to be_falsey
+        end
+      end
+    end
+  end
+end