logstash-core 5.6.16-java → 6.0.0.alpha1-java

data/spec/logstash/settings/writable_directory_spec.rb

@@ -3,17 +3,17 @@ require "spec_helper"
 require "logstash/settings"
 require "tmpdir"
 require "socket" # for UNIXSocket
-require "fileutils"
 
 describe LogStash::Setting::WritableDirectory do
+  let(:mode_rx) { 0555 }
   # linux is 108, Macos is 104, so use a safe value
   # Stud::Temporary.pathname, will exceed that size without adding anything
   let(:parent) { File.join(Dir.tmpdir, Time.now.to_f.to_s) }
   let(:path) { File.join(parent, "fancy") }
 
   before { Dir.mkdir(parent) }
-  after { Dir.exist?(path) && FileUtils.rm_rf(path)}
-  after { FileUtils.rm_rf(parent) }
+  after { Dir.exist?(path) && Dir.unlink(path) rescue nil }
+  after { Dir.unlink(parent) }
 
   shared_examples "failure" do
     before { subject.set(path) }
@@ -44,9 +44,8 @@ describe LogStash::Setting::WritableDirectory do
       end
 
       context "and the directory cannot be created" do
+        before { File.chmod(mode_rx, parent) }
         it "should fail" do
-          # using chmod does not work on Windows better mock and_raise("message")
-          expect(FileUtils).to receive(:mkdir_p).and_raise("foobar")
           expect { subject.value }.to raise_error
         end
       end
@@ -67,8 +66,7 @@ describe LogStash::Setting::WritableDirectory do
       end
 
       context "but is not writable" do
-        # chmod does not work on Windows, mock writable? instead
-        before { expect(File).to receive(:writable?).and_return(false) }
+        before { File.chmod(0, path) }
         it_behaves_like "failure"
       end
     end
@@ -86,13 +84,12 @@ describe LogStash::Setting::WritableDirectory do
         before { socket } # realize `socket` value
         after { socket.close }
         it_behaves_like "failure"
-      end unless LogStash::Environment.windows?
+      end
 
-      
       context "but is a symlink" do
-        before { FileUtils.symlink("whatever", path) }
+        before { File::symlink("whatever", path) }
         it_behaves_like "failure"
-      end unless LogStash::Environment.windows?
+      end
     end
 
     context "when the directory is missing" do
@@ -117,8 +114,8 @@ describe LogStash::Setting::WritableDirectory do
 
       context "and cannot be created" do
         before do
-          # chmod does not work on Windows, mock writable? instead
-          expect(File).to receive(:writable?).and_return(false)
+          # Remove write permission on the parent
+          File.chmod(mode_rx, parent)
         end
 
         it_behaves_like "failure"

data/spec/logstash/settings_spec.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require "spec_helper"
-require "logstash/util/environment_variables"
 require "logstash/settings"
 require "fileutils"
 
@@ -147,94 +146,4 @@ describe LogStash::Settings do
       end
     end
   end
-
-  describe "#from_yaml" do
-
-    context "env placeholders in flat logstash.yml" do
-
-      after do
-        ENV.delete('SOME_LOGSTASH_SPEC_ENV_VAR')
-        ENV.delete('some.logstash.spec.env.var')
-      end
-      
-      subject do
-        settings = described_class.new
-        settings.register(LogStash::Setting::String.new("interpolated", "missing"))
-        settings.register(LogStash::Setting::String.new("with_dot", "missing"))
-        settings
-      end
-
-      let(:values) {{
-        "interpolated" => "${SOME_LOGSTASH_SPEC_ENV_VAR}",
-        "with_dot" => "${some.logstash.spec.env.var}"
-      }}
-      let(:yaml_path) do
-        p = Stud::Temporary.pathname
-        FileUtils.mkdir_p(p)
-
-        ::File.open(::File.join(p, "logstash.yml"), "w+") do |f|
-          f.write(YAML.dump(values))
-        end
-        p
-      end
-
-      it "can interpolate environment into settings" do
-        expect(subject.get('interpolated')).to eq("missing")
-        expect(subject.get('with_dot')).to eq("missing")
-        ENV['SOME_LOGSTASH_SPEC_ENV_VAR'] = "correct_setting"
-        ENV['some.logstash.spec.env.var'] = "correct_setting_for_dotted"
-        subject.from_yaml(yaml_path)
-        expect(subject.get('interpolated')).to eq("correct_setting")
-        expect(subject.get('with_dot')).to eq("correct_setting_for_dotted")
-      end
-    end
-  end
-
-  context "env placeholders in nested logstash.yml" do
-
-    before do
-      ENV['lsspecdomain'] = "domain1"
-      ENV['lsspecdomain2'] = "domain2"
-    end
-
-    after do
-      ENV.delete('lsspecdomain')
-      ENV.delete('lsspecdomain2')
-    end
-
-    subject do
-      settings = described_class.new
-      settings.register(LogStash::Setting::ArrayCoercible.new("host", String, []))
-      settings.register(LogStash::Setting::ArrayCoercible.new("modules", Hash, []))
-      settings
-    end
-
-    let(:values) {{
-      "host" => ["dev1.${lsspecdomain}", "dev2.${lsspecdomain}"],
-      "modules" => [
-        {"name" => "${lsspecdomain}", "testing" => "${lsspecdomain}"}, 
-        {"name" => "${lsspecdomain2}", "testing" => "${lsspecdomain2}"}
-      ]
-    }}
-    let(:yaml_path) do
-      p = Stud::Temporary.pathname
-      FileUtils.mkdir_p(p)
-
-      ::File.open(::File.join(p, "logstash.yml"), "w+") do |f|
-        f.write(YAML.dump(values))
-      end
-      p
-    end
-
-    it "can interpolate environment into settings" do
-      expect(subject.get('host')).to match_array([])
-      expect(subject.get('modules')).to match_array([])
-      subject.from_yaml(yaml_path)
-      expect(subject.get('host')).to match_array(["dev1.domain1", "dev2.domain1"])
-      expect(subject.get('modules')).to match_array([
-                                                      {"name" => "domain1", "testing" => "domain1"},
-                                                      {"name" => "domain2", "testing" => "domain2"}
-                                                    ])
-    end
-  end
 end

data/spec/logstash/state_resolver_spec.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+require "spec_helper"
+require_relative "../support/helpers"
+require_relative "../support/matchers"
+require "logstash/state_resolver"
+require "logstash/config/pipeline_config"
+require "logstash/instrument/null_metric"
+require "logstash/pipeline"
+require "ostruct"
+require "digest"
+
+describe LogStash::StateResolver do
+  subject { described_class.new(metric) }
+  let(:metric) { LogStash::Instrument::NullMetric.new }
+
+  before do
+    clear_data_dir
+  end
+
+  after do
+    # ensure that the the created pipeline are closed
+    running_pipelines.each { |_, pipeline| pipeline.close }
+  end
+
+  context "when no pipeline is running" do
+    let(:running_pipelines) { {} }
+
+    context "no pipeline configs is received" do
+      let(:pipeline_configs) { [] }
+
+      it "returns no action" do
+        expect(subject.resolve(running_pipelines, pipeline_configs).size).to eq(0)
+      end
+    end
+
+    context "we receive some pipeline configs" do
+      let(:pipeline_configs) { [mock_pipeline_config(:hello_world)] }
+
+      it "returns some actions" do
+        expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+          [:create, :hello_world],
+        )
+      end
+    end
+  end
+
+  context "when some pipeline are running" do
+    context "when a pipeline is running" do
+      let(:running_pipelines) { { :main => mock_pipeline(:main) } }
+
+      context "when the pipeline config contains a new one and the existing" do
+        let(:pipeline_configs) { [mock_pipeline_config(:hello_world), mock_pipeline_config(:main)] }
+
+        it "creates the new one and keep the other one" do
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+            [:create, :hello_world],
+          )
+        end
+
+        context "when the pipeline config contains only the new one" do
+          let(:pipeline_configs) { [mock_pipeline_config(:hello_world)] }
+
+          it "creates the new one and stop the old one one" do
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+              [:create, :hello_world],
+              [:stop, :main]
+            )
+          end
+        end
+
+        context "when the pipeline config contains no pipeline" do
+          let(:pipeline_configs) { [] }
+
+          it "stops the old one one" do
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+              [:stop, :main]
+            )
+          end
+        end
+
+        context "when pipeline config contains an updated pipeline" do
+          let(:pipeline_configs) { [mock_pipeline_config(:main, "input { generator {}}")] }
+
+          it "reloads the old one one" do
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+              [:reload, :main]
+            )
+          end
+        end
+      end
+    end
+
+    context "when we have a lot of pipeline running" do
+      let(:running_pipelines) do
+        {
+          :main1 => mock_pipeline(:main1),
+          :main2 => mock_pipeline(:main2),
+          :main3 => mock_pipeline(:main3),
+          :main4 => mock_pipeline(:main4),
+          :main5 => mock_pipeline(:main5),
+          :main6 => mock_pipeline(:main6),
+        }
+      end
+
+      context "without system pipeline" do
+        let(:pipeline_configs) do
+          [
+            mock_pipeline_config(:main1),
+            mock_pipeline_config(:main9),
+            mock_pipeline_config(:main5, "input { generator {}}"),
+            mock_pipeline_config(:main3, "input { generator {}}"),
+            mock_pipeline_config(:main7)
+          ]
+        end
+
+        it "generates actions required to converge" do
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+            [:create, :main7],
+            [:create, :main9],
+            [:reload, :main3],
+            [:reload, :main5],
+            [:stop, :main2],
+            [:stop, :main4],
+            [:stop, :main6]
+          )
+        end
+      end
+
+      context "with system pipeline" do
+        let(:pipeline_configs) do
+          [
+            mock_pipeline_config(:main1),
+            mock_pipeline_config(:main9),
+            mock_pipeline_config(:main5, "input { generator {}}"),
+            mock_pipeline_config(:main3, "input { generator {}}"),
+            mock_pipeline_config(:main7),
+            mock_pipeline_config(:monitoring, "input { generator {}}", { "pipeline.system" => true }),
+          ]
+        end
+
+        it "creates the system pipeline before user defined pipelines" do
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
+            [:create, :monitoring],
+            [:create, :main7],
+            [:create, :main9],
+            [:reload, :main3],
+            [:reload, :main5],
+            [:stop, :main2],
+            [:stop, :main4],
+            [:stop, :main6]
+          )
+        end
+      end
+    end
+  end
+end

data/spec/logstash/timestamp_spec.rb

@@ -7,10 +7,10 @@ describe LogStash::Timestamp do
   context "constructors" do
     it "should work" do
       t = LogStash::Timestamp.new
-      expect(t.time.to_i).to be_within(2).of Time.now.to_i
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
 
       t = LogStash::Timestamp.now
-      expect(t.time.to_i).to be_within(2).of Time.now.to_i
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
 
       now = Time.now.utc
       t = LogStash::Timestamp.new(now)
@@ -30,10 +30,6 @@ describe LogStash::Timestamp do
       expect{LogStash::Timestamp.new("foobar")}.to raise_error
     end
 
-    it "should copy itself correctly on clone and dup" do
-      expect(LogStash::Timestamp.now.clone.to_java).not_to be_nil
-      expect(LogStash::Timestamp.now.dup.to_java).not_to be_nil
-    end
   end
 
 end

data/spec/logstash/util/java_version_spec.rb

@@ -39,6 +39,28 @@ describe "LogStash::Util::JavaVersion" do
     expect(mod.bad_java_version?("pwi3270sr9fp10-20150708_01 (SR9 FP10)")).to be_falsey
   end
 
+  context ".validate_java_version!" do
+    context "with good version" do
+      before do
+        expect(mod).to receive(:version).and_return("1.8.0")
+      end
+
+      it "doesn't raise an error" do
+        expect { mod.validate_java_version! }.not_to raise_error
+      end
+    end
+
+    context "with a bad version" do
+      before do
+        expect(mod).to receive(:version).and_return("1.7.0").twice
+      end
+
+      it "raises an error" do
+        expect { mod.validate_java_version! }.to raise_error RuntimeError, /Java version 1.8.0 or later/
+      end
+    end
+  end
+
   describe "parsing java versions" do
     it "should return nil on a nil version" do
       expect(mod.parse_java_version(nil)).to be_nil

data/spec/logstash/util/safe_uri_spec.rb

@@ -16,61 +16,5 @@ module LogStash module Util
         expect(cloned_safe_uri.query).to eq("a=b")
       end
     end
-
-    describe "handling escapable fields" do
-      let(:user) { "u%20" }
-      let(:password) { "p%20ss" }
-      let(:path) { "/a%20/path" }
-      let(:query) { "a%20query&another=es%3dq" }
-      let(:fragment) { "spacey%20fragment" }
-      subject { LogStash::Util::SafeURI.new("http://#{user}:#{password}@example.net#{path}?#{query}\##{fragment}") }
-
-      [:user, :password, :path, :query, :fragment].each do |field|
-        it "should not escape the #{field} field" do
-          expected = self.send(field)
-          expect(subject.send(field)).to eq(expected)
-        end
-      end
-    end
-
-    describe "#initialize" do
-      context 'when host is required' do
-        MALFORMED_URIS = ['http:/user:pass@localhost:9600', 'http:/localhost', 'http:/localhost:9600', 'h;localhost', 'http:://localhost']
-
-        context 'malformed uris via string' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              expect{LogStash::Util::SafeURI.new(arg)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'malformed uris via java.net.URI' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              java_uri = java.net.URI.new(arg)
-              expect{LogStash::Util::SafeURI.new(java_uri)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'malformed uris via Ruby URI' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              ruby_uri = URI.parse(arg)
-              expect{LogStash::Util::SafeURI.new(ruby_uri)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'uris with a valid host' do
-          ['http://user:pass@notlocalhost:9600', 'http://notlocalhost', 'https://notlocalhost:9600', '//notlocalhost', 'notlocalhost', 'notlocalhost:9200'].each do |arg|
-            it "#{arg}: should resolve host correctly" do
-              expect(LogStash::Util::SafeURI.new(arg).host).to eq('notlocalhost')
-            end
-          end
-        end
-      end
-    end
   end
 end end

data/spec/logstash/util/wrapped_synchronous_queue_spec.rb

@@ -4,6 +4,28 @@ require "logstash/util/wrapped_synchronous_queue"
 require "logstash/instrument/collector"
 
 describe LogStash::Util::WrappedSynchronousQueue do
+  context "#offer" do
+    context "queue is blocked" do
+      it "fails and give feedback" do
+        expect(subject.offer("Bonjour", 2)).to be_falsey
+      end
+    end
+
+    context "queue is not blocked" do
+      before do
+        @consumer = Thread.new { loop { subject.take } }
+        sleep(0.1)
+      end
+
+      after do
+        @consumer.kill
+      end
+
+      it "inserts successfully" do
+        expect(subject.offer("Bonjour", 20)).to be_truthy
+      end
+    end
+  end
 
   describe "queue clients" do
     context "when requesting a write client" do