logstash-core 6.8.20-java → 7.0.0.alpha1-java

data/lib/logstash/pipelines_registry.rb

@@ -1,166 +0,0 @@
-# encoding: utf-8
-
-module LogStash
-  class PipelineState
-    attr_reader :pipeline_id, :pipeline
-
-    def initialize(pipeline_id, pipeline)
-      @pipeline_id = pipeline_id
-      @pipeline = pipeline
-      @reloading = Concurrent::AtomicBoolean.new(false)
-    end
-
-    def terminated?
-      # a reloading pipeline is never considered terminated
-      @reloading.false? && @pipeline.finished_execution?
-    end
-
-    def set_reloading(is_reloading)
-      @reloading.value = is_reloading
-    end
-
-    def set_pipeline(pipeline)
-      raise(ArgumentError, "invalid nil pipeline") if pipeline.nil?
-      @pipeline = pipeline
-    end
-  end
-
-  class PipelinesRegistry
-    attr_reader :states
-    include LogStash::Util::Loggable
-
-    def initialize
-      # we leverage the semantic of the Java ConcurrentHashMap for the
-      # compute() method which is atomic; calling compute() concurrently
-      # will block until the other compute finishes so no mutex is necessary
-      # for synchronizing compute calls
-      @states = java.util.concurrent.ConcurrentHashMap.new
-    end
-
-    # Execute the passed creation logic block and create a new state upon success
-    # @param pipeline_id [String, Symbol] the pipeline id
-    # @param pipeline [Pipeline] the new pipeline to create
-    # @param create_block [Block] the creation execution logic
-    #
-    # @yieldreturn [Boolean] the new pipeline creation success
-    #
-    # @return [Boolean] new pipeline creation success
-    def create_pipeline(pipeline_id, pipeline, &create_block)
-      success = false
-
-      @states.compute(pipeline_id) do |_, state|
-        if state
-          if state.terminated?
-            success = yield
-            state.set_pipeline(pipeline)
-          else
-            logger.error("Attempted to create a pipeline that already exists", :pipeline_id => pipeline_id)
-          end
-          state
-        else
-          success = yield
-          success ? PipelineState.new(pipeline_id, pipeline) : nil
-        end
-      end
-
-      success
-    end
-
-    # Execute the passed termination logic block
-    # @param pipeline_id [String, Symbol] the pipeline id
-    # @param stop_block [Block] the termination execution logic
-    #
-    # @yieldparam [Pipeline] the pipeline to terminate
-    def terminate_pipeline(pipeline_id, &stop_block)
-      @states.compute(pipeline_id) do |_, state|
-        if state.nil?
-          logger.error("Attempted to terminate a pipeline that does not exists", :pipeline_id => pipeline_id)
-          nil
-        else
-          yield(state.pipeline)
-          state
-        end
-      end
-    end
-
-    # Execute the passed reloading logic block in the context of the reloading state and set new pipeline in state
-    # @param pipeline_id [String, Symbol] the pipeline id
-    # @param reload_block [Block] the reloading execution logic
-    #
-    # @yieldreturn [Array<Boolean, Pipeline>] the new pipeline creation success and new pipeline object
-    #
-    # @return [Boolean] new pipeline creation success
-    def reload_pipeline(pipeline_id, &reload_block)
-      success = false
-
-      @states.compute(pipeline_id) do |_, state|
-        if state.nil?
-          logger.error("Attempted to reload a pipeline that does not exists", :pipeline_id => pipeline_id)
-          nil
-        else
-          state.set_reloading(true)
-          begin
-            success, new_pipeline = yield
-            state.set_pipeline(new_pipeline)
-          ensure
-            state.set_reloading(false)
-          end
-          state
-        end
-      end
-
-      success
-    end
-
-    # @param pipeline_id [String, Symbol] the pipeline id
-    # @return [Pipeline] the pipeline object or nil if none for pipeline_id
-    def get_pipeline(pipeline_id)
-      state = @states.get(pipeline_id)
-      state.nil? ? nil : state.pipeline
-    end
-
-    # @return [Fixnum] number of items in the states collection
-    def size
-      @states.size
-    end
-
-    # @return [Boolean] true if the states collection is empty.
-    def empty?
-      @states.isEmpty
-    end
-
-    # @return [Hash{String=>Pipeline}]
-    def running_pipelines
-      select_pipelines { |state| !state.terminated? }
-    end
-
-    # @return [Hash{String=>Pipeline}]
-    def non_running_pipelines
-      select_pipelines { |state| state.terminated? }
-    end
-
-    # @return [Hash{String=>Pipeline}]
-    def running_user_defined_pipelines
-      select_pipelines { |state | !state.terminated? && !state.pipeline.system? }
-    end
-
-    private
-
-    # Returns a mapping of pipelines by their ids.
-    # Pipelines can optionally be filtered by their `PipelineState` by passing
-    # a block that returns truthy when a pipeline should be included in the
-    # result.
-    #
-    # @yieldparam [PipelineState]
-    # @yieldreturn [Boolean]
-    #
-    # @return [Hash{String=>Pipeline}]
-    def select_pipelines(&optional_state_filter)
-      @states.each_with_object({}) do |(id, state), memo|
-        if state && (!block_given? || yield(state))
-          memo[id] = state.pipeline
-        end
-      end
-    end
-  end
-end

data/lib/logstash/util/lazy_singleton.rb

@@ -1,33 +0,0 @@
-require 'thread' # Mutex
-
-# A [LazySingleton] wraps the result of the provided block,
-# which is guaranteed to be called at-most-once, even if the
-# block's return value is nil.
-class ::LogStash::Util::LazySingleton
-
-  def initialize(&block)
-    @mutex = Mutex.new
-    @block = block
-    @instantiated = false
-  end
-
-  def instance
-    unless @instantiated
-      @mutex.synchronize do
-        unless @instantiated
-          @instance = @block.call
-          @instantiated = true
-        end
-      end
-    end
-
-    return @instance
-  end
-
-  def reset!
-    @mutex.synchronize do
-      @instantiated = false
-      @instance = nil
-    end
-  end
-end

data/spec/logstash/jruby_version_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-
-describe "JRuby Version" do
-  it "should break on JRuby version change" do
-    # This spec will break upon JRuby version change to make sure we
-    # verify if resolv.rb has been fixed in Jruby so we can get rid of
-    # lib/logstash/patches/resolv.rb.
-    # ref:
-    #   https://github.com/logstash-plugins/logstash-filter-dns/issues/51
-    #   https://github.com/jruby/jruby/pull/5722
-    expect(JRUBY_VERSION).to eq("9.2.7.0")
-  end
-end
-

data/spec/logstash/pipelines_registry_spec.rb

@@ -1,220 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/pipelines_registry"
-
-describe LogStash::PipelinesRegistry do
-
-  let(:pipeline_id) { "test" }
-  let(:pipeline) { double("Pipeline") }
-  let (:logger) { double("Logger") }
-
-  context "at object creation" do
-    it "should be empty" do
-      expect(subject.size).to eq(0)
-      expect(subject.empty?).to be_truthy
-      expect(subject.running_pipelines).to be_empty
-      expect(subject.non_running_pipelines).to be_empty
-      expect(subject.running_user_defined_pipelines).to be_empty
-    end
-  end
-
-  context "creating a pipeline" do
-    context "without existing same pipeline id" do
-      it "registry should not have a state for pipeline_id" do
-        expect(subject.get_pipeline(pipeline_id)).to be_nil
-      end
-
-      it "should return block return value" do
-        expect(subject.create_pipeline(pipeline_id, pipeline) { "dummy" }).to eq("dummy")
-      end
-
-      it "should register the new pipeline upon successful create block" do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-        expect(subject.get_pipeline(pipeline_id)).to eq(pipeline)
-      end
-
-      it "should not register the new pipeline upon unsuccessful create block" do
-        subject.create_pipeline(pipeline_id, pipeline) { false }
-        expect(subject.get_pipeline(pipeline_id)).to be_nil
-      end
-    end
-
-    context "with existing pipeline id" do
-      before :each do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-      end
-
-      it "registry should have a state for pipeline_id" do
-        expect(subject.get_pipeline(pipeline_id)).to eq(pipeline)
-      end
-
-      context "when existing pipeline is not terminated" do
-        before :each do
-          expect(pipeline).to receive(:finished_execution?).and_return(false)
-        end
-
-        it "should return false" do
-          expect(subject.create_pipeline(pipeline_id, pipeline) { "dummy" }).to be_falsey
-        end
-
-        it "should not call block and log error if pipeline is not terminated" do
-          expect(LogStash::PipelinesRegistry).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:error)
-          expect { |b| subject.create_pipeline(pipeline_id, pipeline, &b) }.not_to yield_control
-        end
-      end
-
-      context "when existing pipeline is terminated" do
-        let (:new_pipeline) { double("New Pipeline") }
-
-        before :each do
-          expect(pipeline).to receive(:finished_execution?).and_return(true)
-        end
-
-        it "should return block value" do
-          expect(subject.create_pipeline(pipeline_id, new_pipeline) { "dummy" }).to eq("dummy")
-        end
-
-        it "should return block value" do
-          expect(subject.create_pipeline(pipeline_id, new_pipeline) { "dummy" }).to eq("dummy")
-        end
-
-        it "should register new pipeline" do
-          subject.create_pipeline(pipeline_id, new_pipeline) { true }
-          expect(subject.get_pipeline(pipeline_id)).to eq(new_pipeline)
-        end
-      end
-    end
-  end
-
-  context "terminating a pipeline" do
-    context "without existing pipeline id" do
-      it "should log error" do
-        expect(LogStash::PipelinesRegistry).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:error)
-        subject.terminate_pipeline(pipeline_id) { "dummy" }
-      end
-
-      it "should not yield to block" do
-        expect { |b| subject.terminate_pipeline(pipeline_id, &b) }.not_to yield_control
-      end
-    end
-
-    context "with existing pipeline id" do
-      before :each do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-      end
-
-      it "should yield to block" do
-        expect { |b| subject.terminate_pipeline(pipeline_id, &b) }.to yield_control
-      end
-
-      it "should keep pipeline id" do
-        subject.terminate_pipeline(pipeline_id) { "dummy" }
-        expect(subject.get_pipeline(pipeline_id)).to eq(pipeline)
-      end
-    end
-  end
-
-  context "reloading a pipeline" do
-    it "should log error with inexistent pipeline id" do
-      expect(LogStash::PipelinesRegistry).to receive(:logger).and_return(logger)
-      expect(logger).to receive(:error)
-      subject.reload_pipeline(pipeline_id) { }
-    end
-
-    context "with existing pipeline id" do
-      before :each do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-      end
-
-      it "should return block value" do
-        expect(subject.reload_pipeline(pipeline_id) { ["dummy", pipeline] }).to eq("dummy")
-      end
-
-      it "should not be terminated while reloading" do
-        expect(pipeline).to receive(:finished_execution?).and_return(false, true, true)
-
-        # 1st call: finished_execution? is false
-        expect(subject.running_pipelines).not_to be_empty
-
-        # 2nd call: finished_execution? is true
-        expect(subject.running_pipelines).to be_empty
-
-
-        queue = Queue.new # threadsafe queue
-        in_block = Concurrent::AtomicBoolean.new(false)
-
-        thread = Thread.new(subject, pipeline_id, pipeline, queue, in_block) do |subject, pipeline_id, pipeline, queue, in_block|
-          subject.reload_pipeline(pipeline_id) do
-            in_block.make_true
-            queue.pop
-            [true, pipeline]
-          end
-        end
-
-        # make sure we entered the block executioin
-        wait(10).for {in_block.true?}.to be_truthy
-
-        # at this point the thread is suspended waiting on queue
-
-        # since in reloading state, running_pipelines is not empty
-        expect(subject.running_pipelines).not_to be_empty
-
-        # unblock thread
-        queue.push(:dummy)
-        thread.join
-
-        # 3rd call: finished_execution? is true
-        expect(subject.running_pipelines).to be_empty
-      end
-    end
-  end
-
-  context "pipelines collections" do
-    context "with a non terminated pipelines" do
-      before :each do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-        expect(pipeline).to receive(:finished_execution?).and_return(false)
-      end
-
-      it "should find running pipelines" do
-        expect(subject.running_pipelines).not_to be_empty
-      end
-
-      it "should not find non_running pipelines" do
-        expect(subject.non_running_pipelines).to be_empty
-      end
-
-      it "should find running_user_defined_pipelines" do
-        expect(pipeline).to receive(:system?).and_return(false)
-        expect(subject.running_user_defined_pipelines).not_to be_empty
-      end
-
-      it "should not find running_user_defined_pipelines" do
-        expect(pipeline).to receive(:system?).and_return(true)
-        expect(subject.running_user_defined_pipelines).to be_empty
-      end
-    end
-
-    context "with a terminated pipelines" do
-      before :each do
-        subject.create_pipeline(pipeline_id, pipeline) { true }
-        expect(pipeline).to receive(:finished_execution?).and_return(true)
-      end
-
-      it "should not find running pipelines" do
-        expect(subject.running_pipelines).to be_empty
-      end
-
-      it "should find non_running pipelines" do
-        expect(subject.non_running_pipelines).not_to be_empty
-      end
-
-      it "should not find running_user_defined_pipelines" do
-        expect(subject.running_user_defined_pipelines).to be_empty
-      end
-    end
-
-  end
-end