From 5d43c26454da196a4f1e220d4490d1412c2c5c98 Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 1 Apr 2025 10:41:47 +0200 Subject: [PATCH 01/15] Moved PositiveInteger Ruby class to Java SettingPositiveInteger --- logstash-core/spec/logstash/pipeline_pq_file_spec.rb | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb index fe0f80fe68e..acfa62f8609 100644 --- a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb +++ b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb @@ -103,6 +103,7 @@ def close let(:collected_metric) { metric_store.get_with_path("stats/pipelines/") } before :each do + puts "DNADBG>> setup test - start" FileUtils.mkdir_p(this_queue_folder) pipeline_settings_obj.set("path.queue", this_queue_folder) @@ -112,14 +113,21 @@ def close allow(LogStash::Plugin).to receive(:lookup).with("filter", "dummyfilter").and_return(LogStash::Filters::DummyFilter) allow(LogStash::Plugin).to receive(:lookup).with("output", "pipelinepqfileoutput").and_return(PipelinePqFileOutput) + puts "DNADBG>> setup test - workers read" pipeline_workers_setting = LogStash::SETTINGS.get_setting("pipeline.workers") allow(pipeline_workers_setting).to receive(:default).and_return(worker_thread_count) - pipeline_settings.each {|k, v| pipeline_settings_obj.set(k, v) } + puts "DNADBG>> setup test - workers read 2" + pipeline_settings.each {|k, v| + puts "DNADBG>> setup test - workers read 2 before set #{k}" + pipeline_settings_obj.set(k, v) + } + puts "DNADBG>> setup test - workers read 3" pipeline_settings_obj.set("queue.page_capacity", page_capacity) pipeline_settings_obj.set("queue.max_bytes", max_bytes) pipeline_settings_obj.set("queue.drain", true) times.push(Time.now.to_f) + puts "DNADBG>> before start" subject.start sleep(0.1) until subject.ready? From a5e61cd72a7c1999348e783a6bbedf836c0d31b3 Mon Sep 17 00:00:00 2001 From: andsel Date: Fri, 8 Aug 2025 16:47:30 +0200 Subject: [PATCH 02/15] Code clean, removed debug logs --- logstash-core/spec/logstash/pipeline_pq_file_spec.rb | 9 --------- 1 file changed, 9 deletions(-) diff --git a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb index acfa62f8609..a6161c54e43 100644 --- a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb +++ b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb @@ -103,7 +103,6 @@ def close let(:collected_metric) { metric_store.get_with_path("stats/pipelines/") } before :each do - puts "DNADBG>> setup test - start" FileUtils.mkdir_p(this_queue_folder) pipeline_settings_obj.set("path.queue", this_queue_folder) @@ -113,21 +112,13 @@ def close allow(LogStash::Plugin).to receive(:lookup).with("filter", "dummyfilter").and_return(LogStash::Filters::DummyFilter) allow(LogStash::Plugin).to receive(:lookup).with("output", "pipelinepqfileoutput").and_return(PipelinePqFileOutput) - puts "DNADBG>> setup test - workers read" pipeline_workers_setting = LogStash::SETTINGS.get_setting("pipeline.workers") allow(pipeline_workers_setting).to receive(:default).and_return(worker_thread_count) - puts "DNADBG>> setup test - workers read 2" - pipeline_settings.each {|k, v| - puts "DNADBG>> setup test - workers read 2 before set #{k}" - pipeline_settings_obj.set(k, v) - } - puts "DNADBG>> setup test - workers read 3" pipeline_settings_obj.set("queue.page_capacity", page_capacity) pipeline_settings_obj.set("queue.max_bytes", max_bytes) pipeline_settings_obj.set("queue.drain", true) times.push(Time.now.to_f) - puts "DNADBG>> before start" subject.start sleep(0.1) until subject.ready? From 50f5a6cdb2951f7a50d79ec549678ff776d4c1e8 Mon Sep 17 00:00:00 2001 From: andsel Date: Fri, 8 Aug 2025 17:13:51 +0200 Subject: [PATCH 03/15] Minor, reinserted dropped line --- logstash-core/spec/logstash/pipeline_pq_file_spec.rb | 1 + 1 file changed, 1 insertion(+) diff --git a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb index a6161c54e43..fe0f80fe68e 100644 --- a/logstash-core/spec/logstash/pipeline_pq_file_spec.rb +++ b/logstash-core/spec/logstash/pipeline_pq_file_spec.rb @@ -114,6 +114,7 @@ def close pipeline_workers_setting = LogStash::SETTINGS.get_setting("pipeline.workers") allow(pipeline_workers_setting).to receive(:default).and_return(worker_thread_count) + pipeline_settings.each {|k, v| pipeline_settings_obj.set(k, v) } pipeline_settings_obj.set("queue.page_capacity", page_capacity) pipeline_settings_obj.set("queue.max_bytes", max_bytes) pipeline_settings_obj.set("queue.drain", true) From c0286fd741e33b4b5186c73e42e99aa7c38a9fdf Mon Sep 17 00:00:00 2001 From: andsel Date: Mon, 11 Aug 2025 11:20:09 +0200 Subject: [PATCH 04/15] [WIP] First implementation of Port and PortRange classes --- gradle.properties | 2 +- logstash-core/lib/logstash/environment.rb | 6 +- logstash-core/lib/logstash/settings.rb | 97 ++++++++++--------- .../java/org/logstash/settings/Range.java | 32 ++++++ .../org/logstash/settings/SettingPort.java | 30 ++++++ .../logstash/settings/SettingPortRange.java | 60 ++++++++++++ 6 files changed, 180 insertions(+), 47 deletions(-) create mode 100644 logstash-core/src/main/java/org/logstash/settings/Range.java create mode 100644 logstash-core/src/main/java/org/logstash/settings/SettingPort.java create mode 100644 logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java diff --git a/gradle.properties b/gradle.properties index 9a8e756f6ed..6c223bddf0f 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8 +org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8 org.gradle.daemon=false ## from default 30 secs to 2 minutes network timeouts diff --git a/logstash-core/lib/logstash/environment.rb b/logstash-core/lib/logstash/environment.rb index 81c4516478b..a54f551dff9 100644 --- a/logstash-core/lib/logstash/environment.rb +++ b/logstash-core/lib/logstash/environment.rb @@ -33,6 +33,10 @@ module Environment end end + def as_java_range(r) + org::logstash::settings::Range.new(r.first, r.last) + end + [ Setting::Boolean.new("allow_superuser", false), Setting::SettingString.new("node.name", Socket.gethostname), @@ -67,7 +71,7 @@ module Environment Setting::Boolean.new("log.format.json.fix_duplicate_message_fields", true), Setting::Boolean.new("api.enabled", true), Setting::SettingString.new("api.http.host", "127.0.0.1"), - Setting::PortRange.new("api.http.port", 9600..9700), + Setting::PortRange.new("api.http.port", ::LogStash.as_java_range(9600..9700)), Setting::SettingString.new("api.environment", "production"), Setting::SettingString.new("api.auth.type", "none", true, %w(none basic)), Setting::SettingString.new("api.auth.basic.username", nil, false).nullable, diff --git a/logstash-core/lib/logstash/settings.rb b/logstash-core/lib/logstash/settings.rb index ef90cc1f36b..fb5f1123bee 100644 --- a/logstash-core/lib/logstash/settings.rb +++ b/logstash-core/lib/logstash/settings.rb @@ -418,55 +418,62 @@ def coerce(value) java_import org.logstash.settings.SettingInteger java_import org.logstash.settings.SettingPositiveInteger - - class Port < SettingInteger - VALID_PORT_RANGE = 1..65535 - - def initialize(name, default = nil, strict = true) - super(name, default, strict) { |value| valid?(value) } - end - def valid?(port) - VALID_PORT_RANGE.cover?(port) - end - end + # java_import org.logstash.settings.SettingPort + Port = org::logstash::settings::SettingPort - class PortRange < Coercible - PORT_SEPARATOR = "-" - - def initialize(name, default = nil, strict = true) - super(name, ::Range, default, strict = true) { |value| valid?(value) } - end - - def valid?(range) - Port::VALID_PORT_RANGE.first <= range.first && Port::VALID_PORT_RANGE.last >= range.last - end + # class Port < SettingInteger + # VALID_PORT_RANGE = 1..65535 + # + # def initialize(name, default = nil, strict = true) + # super(name, default, strict) { |value| valid?(value) } + # end + # + # def valid?(port) + # VALID_PORT_RANGE.cover?(port) + # end + # end - def coerce(value) - case value - when ::Range - value - when ::Integer - value..value - when ::String - first, last = value.split(PORT_SEPARATOR) - last = first if last.nil? - begin - (Integer(first))..(Integer(last)) - rescue ArgumentError # Trap and reraise a more human error - raise ArgumentError.new("Could not coerce #{value} into a port range") - end - else - raise ArgumentError.new("Could not coerce #{value} into a port range") - end - end + # java_import org.logstash.settings.SettingPortRange + PortRange = org::logstash::settings::SettingPortRange - def validate(value) - unless valid?(value) - raise ArgumentError.new("Invalid value \"#{name}: #{value}\", valid options are within the range of #{Port::VALID_PORT_RANGE.first}-#{Port::VALID_PORT_RANGE.last}") - end - end - end + # class PortRange < Coercible + # PORT_SEPARATOR = "-" + # VALID_PORT_RANGE = 1..65535 + # + # def initialize(name, default = nil, strict = true) + # super(name, ::Range, default, strict = true) { |value| valid?(value) } + # end + # + # def valid?(range) + # VALID_PORT_RANGE.first <= range.first && VALID_PORT_RANGE.last >= range.last + # end + # + # def coerce(value) + # case value + # when ::Range + # value + # when ::Integer + # value..value + # when ::String + # first, last = value.split(PORT_SEPARATOR) + # last = first if last.nil? + # begin + # (Integer(first))..(Integer(last)) + # rescue ArgumentError # Trap and reraise a more human error + # raise ArgumentError.new("Could not coerce #{value} into a port range") + # end + # else + # raise ArgumentError.new("Could not coerce #{value} into a port range") + # end + # end + # + # def validate(value) + # unless valid?(value) + # raise ArgumentError.new("Invalid value \"#{name}: #{value}\", valid options are within the range of #{Port::VALID_PORT_RANGE.first}-#{Port::VALID_PORT_RANGE.last}") + # end + # end + # end class Validator < Setting def initialize(name, default = nil, strict = true, validator_class = nil) diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java new file mode 100644 index 00000000000..f8b632bfa2c --- /dev/null +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -0,0 +1,32 @@ +package org.logstash.settings; + +import org.jruby.RubyRange; +import org.jruby.runtime.ThreadContext; + +public class Range> { + + private final T first; + private final T last; + + public Range(T first, T last) { + this.first = first; + this.last = last; + } + + public boolean contains(Range other) { + return first.compareTo(other.first) <= 0 && last.compareTo(other.last) >= 0; + } + + public T getFirst() { + return first; + } + + public T getLast() { + return last; + } + +// public static Range fromRubyRange(RubyRange r) { +// ThreadContext context = r.getRuntime().getCurrentContext(); +// r.last(context); +// } +} \ No newline at end of file diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPort.java b/logstash-core/src/main/java/org/logstash/settings/SettingPort.java new file mode 100644 index 00000000000..05af23d152a --- /dev/null +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPort.java @@ -0,0 +1,30 @@ +package org.logstash.settings; + +import java.util.function.Predicate; + +public final class SettingPort extends SettingInteger { + + public static final Predicate VALID_PORT_RANGE = new Predicate<>() { + @Override + public boolean test(Integer integer) { + return isValid(integer); + } + }; + + public SettingPort(String name, Integer defaultValue) { + super(name, defaultValue); + } + + public SettingPort(String name, Integer defaultValue, boolean strict) { + this(name, defaultValue, strict, VALID_PORT_RANGE); + } + + protected SettingPort(String name, Integer defaultValue, boolean strict, Predicate validator) { + super(name, defaultValue, strict, validator); + } + + public static boolean isValid(int port) { + return 1 <= port && port <= 65535; + } + +} diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java new file mode 100644 index 00000000000..4fe53d17bc7 --- /dev/null +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java @@ -0,0 +1,60 @@ +package org.logstash.settings; + +import java.util.function.Predicate; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public class SettingPortRange extends Coercible> { + + private static final Range VALID_PORT_RANGE = new Range<>(1, 65535); + public static final String PORT_SEPARATOR = "-"; + + public SettingPortRange(String name, Range defaultValue) { + super(name, defaultValue, true, SettingPortRange::isValid); + } + + public static boolean isValid(Range range) { + return VALID_PORT_RANGE.contains(range); + } + + @Override + public Range coerce(Object obj) { + if (obj instanceof Range) { + return (Range) obj; + } + + if (obj instanceof Integer) { + Integer val = (Integer) obj; + return new Range<>(val, val); + } + + if (obj instanceof String) { + String val = (String) obj; + String[] parts = val.split(PORT_SEPARATOR); + String firstStr = parts[0]; + String lastStr; + if (parts.length == 1) { + lastStr = firstStr; + } else { + lastStr = parts[1]; + } + try { + int first = Integer.parseInt(firstStr); + int last = Integer.parseInt(lastStr); + return new Range<>(first, last); + } catch(NumberFormatException e) { + throw new IllegalArgumentException("Could not coerce " + obj + " into a port range"); + } + } + throw new IllegalArgumentException("Could not coerce " + obj + " into a port range"); + } + + @Override + public void validate(Range value) throws IllegalArgumentException { + if (!isValid(value)) { + final String msg = String.format("Invalid value \"{}: {}}\", valid options are within the range of {}-{}", + getName(), value, VALID_PORT_RANGE, VALID_PORT_RANGE.getFirst(), VALID_PORT_RANGE.getLast()); + + throw new IllegalArgumentException(msg); + } + } +} From f36a55e2d2288926734ebc6352cabe27c63aa246 Mon Sep 17 00:00:00 2001 From: andsel Date: Fri, 22 Aug 2025 17:07:22 +0200 Subject: [PATCH 05/15] Fixed SettingPortRange.coerce when Long value is provided. Added method eachWithIndex to Range to loop on the interval --- logstash-core/lib/logstash/environment.rb | 4 +-- .../java/org/logstash/settings/Range.java | 25 +++++++++++++------ .../logstash/settings/SettingPortRange.java | 10 ++++++-- 3 files changed, 28 insertions(+), 11 deletions(-) diff --git a/logstash-core/lib/logstash/environment.rb b/logstash-core/lib/logstash/environment.rb index a54f551dff9..7e7f243fd04 100644 --- a/logstash-core/lib/logstash/environment.rb +++ b/logstash-core/lib/logstash/environment.rb @@ -33,8 +33,8 @@ module Environment end end - def as_java_range(r) - org::logstash::settings::Range.new(r.first, r.last) + def self.as_java_range(r) + org::logstash::settings::Range.new(r.first.to_java(java.lang.Integer), r.last.to_java(java.lang.Integer)) end [ diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java index f8b632bfa2c..2ea13c6a355 100644 --- a/logstash-core/src/main/java/org/logstash/settings/Range.java +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -1,9 +1,8 @@ package org.logstash.settings; -import org.jruby.RubyRange; -import org.jruby.runtime.ThreadContext; +import java.util.function.BiConsumer; -public class Range> { +public class Range { private final T first; private final T last; @@ -25,8 +24,20 @@ public T getLast() { return last; } -// public static Range fromRubyRange(RubyRange r) { -// ThreadContext context = r.getRuntime().getCurrentContext(); -// r.last(context); -// } + // TODO cover with tests + public void eachWithIndex(BiConsumer consumer) { + // In case of a single value range, we should still yield once + if (first.intValue() == last.intValue()) { + consumer.accept(first.intValue(), 0); + return; + } + int index = 0; + for (int value = first.intValue(); first.intValue() < last.intValue(); value++) { + consumer.accept(value, index++); + } + } + + public int count() { + return last.intValue() - first.intValue() + 1; + } } \ No newline at end of file diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java index 4fe53d17bc7..595437a0101 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java @@ -16,6 +16,7 @@ public static boolean isValid(Range range) { return VALID_PORT_RANGE.contains(range); } + // TODO cover with tests @Override public Range coerce(Object obj) { if (obj instanceof Range) { @@ -27,6 +28,11 @@ public Range coerce(Object obj) { return new Range<>(val, val); } + if (obj instanceof Long) { + Long val = (Long) obj; + return new Range<>(val.intValue(), val.intValue()); + } + if (obj instanceof String) { String val = (String) obj; String[] parts = val.split(PORT_SEPARATOR); @@ -42,10 +48,10 @@ public Range coerce(Object obj) { int last = Integer.parseInt(lastStr); return new Range<>(first, last); } catch(NumberFormatException e) { - throw new IllegalArgumentException("Could not coerce " + obj + " into a port range"); + throw new IllegalArgumentException("Could not coerce [" + obj + "](type: " + obj.getClass() + ") into a port range"); } } - throw new IllegalArgumentException("Could not coerce " + obj + " into a port range"); + throw new IllegalArgumentException("Could not coerce [" + obj + "](type: " + obj.getClass() + ") into a port range"); } @Override From 8ba2530fcc720f289bcec8c9cbb414b1d05a14aa Mon Sep 17 00:00:00 2001 From: andsel Date: Mon, 8 Sep 2025 17:32:21 +0200 Subject: [PATCH 06/15] Updated SettingsPortRange to work on generic Object so that the constructor can coerce on values offered for default value. Fixed failing test trasforming Ruby rage to newly introduced Java Range class --- logstash-core/spec/logstash/runner_spec.rb | 6 ++--- .../spec/logstash/settings/port_range_spec.rb | 18 +++++++-------- logstash-core/spec/logstash/settings_spec.rb | 2 +- .../java/org/logstash/settings/Range.java | 22 ++++++++++++++++++ .../logstash/settings/SettingPortRange.java | 23 +++++++++++-------- 5 files changed, 49 insertions(+), 22 deletions(-) diff --git a/logstash-core/spec/logstash/runner_spec.rb b/logstash-core/spec/logstash/runner_spec.rb index 5e325c739b0..d4b683ce160 100644 --- a/logstash-core/spec/logstash/runner_spec.rb +++ b/logstash-core/spec/logstash/runner_spec.rb @@ -321,7 +321,7 @@ it "creates an Agent whose `api.http.port` uses the default value" do expect(LogStash::Agent).to receive(:new) do |settings| expect(settings.set?("api.http.port")).to be_falsey - expect(settings.get("api.http.port")).to eq(9600..9700) + expect(settings.get("api.http.port")).to eq(::LogStash.as_java_range(9600..9700)) end subject.run("bin/logstash", args) @@ -335,7 +335,7 @@ it "creates an Agent whose `api.http.port` is an appropriate single-element range" do expect(LogStash::Agent).to receive(:new) do |settings| expect(settings.set?("api.http.port")).to be(true) - expect(settings.get("api.http.port")).to eq(10000..10000) + expect(settings.get("api.http.port")).to eq(::LogStash.as_java_range(10000..10000)) end subject.run("bin/logstash", args) @@ -346,7 +346,7 @@ it "creates an Agent whose `api.http.port` uses the appropriate inclusive-end range" do expect(LogStash::Agent).to receive(:new) do |settings| expect(settings.set?("api.http.port")).to be(true) - expect(settings.get("api.http.port")).to eq(10000..20000) + expect(settings.get("api.http.port")).to eq(::LogStash.as_java_range(10000..20000)) end subject.run("bin/logstash", args) diff --git a/logstash-core/spec/logstash/settings/port_range_spec.rb b/logstash-core/spec/logstash/settings/port_range_spec.rb index 367b558ab1a..4d257776546 100644 --- a/logstash-core/spec/logstash/settings/port_range_spec.rb +++ b/logstash-core/spec/logstash/settings/port_range_spec.rb @@ -27,12 +27,12 @@ end it "returns a range" do - expect(subject.value).to eq(9000..9000) + expect(subject.value).to eq(::LogStash.as_java_range(9000..9000)) end it "can update the range" do subject.set(10000) - expect(subject.value).to eq(10000..10000) + expect(subject.value).to eq(::LogStash.as_java_range(10000..10000)) end end @@ -48,12 +48,12 @@ end it "returns a range" do - expect(subject.value).to eq(9000..10000) + expect(subject.value).to eq(::LogStash.as_java_range(9000..10000)) end it "can update the range" do subject.set("500-1000") - expect(subject.value).to eq(500..1000) + expect(subject.value).to eq(::LogStash.as_java_range(500..1000)) end end @@ -82,23 +82,23 @@ end context "When value is a range" do - subject { LogStash::Setting::PortRange.new("mynewtest", 9000..10000) } + subject { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(9000..10000)) } it "accepts a ruby range as the default value" do expect { subject }.not_to raise_error end it "can update the range" do - subject.set(500..1000) - expect(subject.value).to eq(500..1000) + subject.set(::LogStash.as_java_range(500..1000)) + expect(subject.value).to eq(::LogStash.as_java_range(500..1000)) end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", 9000..1000000) }.to raise_error + expect { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(9000..1000000)) }.to raise_error end it "raise an exception on when port are out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", -1000..1000) }.to raise_error + expect { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(-1000..1000)) }.to raise_error end end end diff --git a/logstash-core/spec/logstash/settings_spec.rb b/logstash-core/spec/logstash/settings_spec.rb index afd0ed630a1..09dfc018278 100644 --- a/logstash-core/spec/logstash/settings_spec.rb +++ b/logstash-core/spec/logstash/settings_spec.rb @@ -64,7 +64,7 @@ describe "#to_hash" do let(:java_deprecated_alias) { LogStash::Setting::Boolean.new("java.actual", true).with_deprecated_alias("java.deprecated") } - let(:ruby_deprecated_alias) { LogStash::Setting::PortRange.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } + let(:ruby_deprecated_alias) { LogStash::Setting::PortRange.new("ruby.actual", ::LogStash.as_java_range(9600..9700)).with_deprecated_alias("ruby.deprecated") } let(:non_deprecated) { LogStash::Setting::Boolean.new("plain_setting", false) } before :each do diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java index 2ea13c6a355..f328603f540 100644 --- a/logstash-core/src/main/java/org/logstash/settings/Range.java +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -1,5 +1,6 @@ package org.logstash.settings; +import java.util.Objects; import java.util.function.BiConsumer; public class Range { @@ -40,4 +41,25 @@ public void eachWithIndex(BiConsumer consumer) { public int count() { return last.intValue() - first.intValue() + 1; } + + @Override + public String toString() { + return this.getClass().getName() + + "{first=" + first + + ", last=" + last + + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + Range range = (Range) o; + return Objects.equals(first, range.first) && Objects.equals(last, range.last); + } + + @Override + public int hashCode() { + return Objects.hash(first, last); + } } \ No newline at end of file diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java index 595437a0101..e6d0a38c981 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java @@ -1,19 +1,24 @@ package org.logstash.settings; -import java.util.function.Predicate; - +// Ideally would be a Coercible>, but given the fact that +// values can be effectively coerced into the constructor, it needs instances +// of Objects to represent Integer, String, Long to be later coerced into Range. @SuppressWarnings({"rawtypes", "unchecked"}) -public class SettingPortRange extends Coercible> { +public class SettingPortRange extends Coercible { private static final Range VALID_PORT_RANGE = new Range<>(1, 65535); public static final String PORT_SEPARATOR = "-"; - public SettingPortRange(String name, Range defaultValue) { + public SettingPortRange(String name, Object defaultValue) { super(name, defaultValue, true, SettingPortRange::isValid); } - public static boolean isValid(Range range) { - return VALID_PORT_RANGE.contains(range); + public static boolean isValid(Object range) { + if (!(range instanceof Range)) { + return false; + } + + return VALID_PORT_RANGE.contains((Range) range); } // TODO cover with tests @@ -55,10 +60,10 @@ public Range coerce(Object obj) { } @Override - public void validate(Range value) throws IllegalArgumentException { + public void validate(Object value) throws IllegalArgumentException { if (!isValid(value)) { - final String msg = String.format("Invalid value \"{}: {}}\", valid options are within the range of {}-{}", - getName(), value, VALID_PORT_RANGE, VALID_PORT_RANGE.getFirst(), VALID_PORT_RANGE.getLast()); + final String msg = String.format("Invalid value \"%s: %s\", valid options are within the range of %d-%d", + getName(), value, VALID_PORT_RANGE.getFirst(), VALID_PORT_RANGE.getLast()); throw new IllegalArgumentException(msg); } From 3e6dfeef323ed6a195f506fc29fd1e44446d0ecb Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 9 Sep 2025 11:10:08 +0200 Subject: [PATCH 07/15] Minor, added license header to new files --- gradle.properties | 2 +- .../java/org/logstash/settings/Range.java | 19 +++++++++++++++++++ .../org/logstash/settings/SettingPort.java | 19 +++++++++++++++++++ .../logstash/settings/SettingPortRange.java | 19 +++++++++++++++++++ 4 files changed, 58 insertions(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 6c223bddf0f..9a8e756f6ed 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8 +org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8 org.gradle.daemon=false ## from default 30 secs to 2 minutes network timeouts diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java index f328603f540..18115d2e6fc 100644 --- a/logstash-core/src/main/java/org/logstash/settings/Range.java +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -1,3 +1,22 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + package org.logstash.settings; import java.util.Objects; diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPort.java b/logstash-core/src/main/java/org/logstash/settings/SettingPort.java index 05af23d152a..b1d93ea217c 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPort.java +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPort.java @@ -1,3 +1,22 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + package org.logstash.settings; import java.util.function.Predicate; diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java index e6d0a38c981..d3f5cdbd2d0 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java @@ -1,3 +1,22 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + package org.logstash.settings; // Ideally would be a Coercible>, but given the fact that From 80e252bc2637551db1de36d7123c9c52dcec9e64 Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 9 Sep 2025 11:51:17 +0200 Subject: [PATCH 08/15] [Test] Covered Java Range class with tests --- .../java/org/logstash/settings/Range.java | 10 ++- .../java/org/logstash/settings/RangeTest.java | 84 +++++++++++++++++++ 2 files changed, 90 insertions(+), 4 deletions(-) create mode 100644 logstash-core/src/test/java/org/logstash/settings/RangeTest.java diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java index 18115d2e6fc..5a00a270980 100644 --- a/logstash-core/src/main/java/org/logstash/settings/Range.java +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -28,8 +28,11 @@ public class Range { private final T last; public Range(T first, T last) { - this.first = first; - this.last = last; + this.first = Objects.requireNonNull(first); + this.last =Objects.requireNonNull(last); + if (first.compareTo(last) > 0) { + throw new IllegalArgumentException("First must be less than or equal to last"); + } } public boolean contains(Range other) { @@ -44,7 +47,6 @@ public T getLast() { return last; } - // TODO cover with tests public void eachWithIndex(BiConsumer consumer) { // In case of a single value range, we should still yield once if (first.intValue() == last.intValue()) { @@ -52,7 +54,7 @@ public void eachWithIndex(BiConsumer consumer) { return; } int index = 0; - for (int value = first.intValue(); first.intValue() < last.intValue(); value++) { + for (int value = first.intValue(); value < last.intValue(); value++) { consumer.accept(value, index++); } } diff --git a/logstash-core/src/test/java/org/logstash/settings/RangeTest.java b/logstash-core/src/test/java/org/logstash/settings/RangeTest.java new file mode 100644 index 00000000000..6c46b43fc17 --- /dev/null +++ b/logstash-core/src/test/java/org/logstash/settings/RangeTest.java @@ -0,0 +1,84 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.logstash.settings; + +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class RangeTest { + + int count = 0; + + @Before + public void setUp() { + count = 0; + } + + @Test + public void givenRangeCompletelyOverlappingAnotherThenContainsReturnTrue() { + Range container = new Range<>(5, 10); + Range contained = new Range<>(6, 9); + assertTrue(container.contains(contained)); + assertFalse(contained.contains(container)); + } + + @Test + public void givenRangePartiallyOverlappingAnotherThenContainsReturnFalse() { + Range container = new Range<>(5, 10); + Range left = new Range<>(3, 6); + Range right = new Range<>(7, 11); + assertFalse(container.contains(left)); + assertFalse(container.contains(right)); + } + + @Test + public void givenRangeWithSameBoundsThenCountReturnOne() { + Range singlePointRange = new Range<>(5, 5); + assertEquals(1, singlePointRange.count()); + } + + @Test + public void givenRangeWithDifferentBoundsThenCountReturnCorrectValue() { + Range range = new Range<>(5, 10); + assertEquals(6, range.count()); + } + + @Test + public void givenRangeWhenIteratorIsInvokedCorrectNumberOfTimes() { + // start bound inclusive, end bound exclusive + Range range = new Range<>(5, 10); + range.eachWithIndex((value, index) -> count++); + assertEquals(5, count); + } + + @Test + public void givenRangeWithSameBoundsWhenIteratorIsInvokedJustOneTime() { + Range singlePointRange = new Range<>(5, 5); + singlePointRange.eachWithIndex((value, index) -> count++); + assertEquals(1, singlePointRange.count()); + } + + @Test(expected = IllegalArgumentException.class) + public void givenRangeWithFirstGreaterThanLastThenThrowIllegalArgumentException() { + new Range<>(10, 5); + } +} \ No newline at end of file From c72b6bb23d069c354c2eb4217f20324f110cab40 Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 9 Sep 2025 15:03:55 +0200 Subject: [PATCH 09/15] [Test] Covered Java class SettingPortRange with JUnit test copied from Ruby specs --- .../settings/SettingPortRangeTest.java | 141 ++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java diff --git a/logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java b/logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java new file mode 100644 index 00000000000..953dced5e5e --- /dev/null +++ b/logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java @@ -0,0 +1,141 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.logstash.settings; + +import org.jruby.RubyFixnum; +import org.jruby.RubyRange; +import org.jruby.runtime.ThreadContext; +import org.junit.Test; +import org.logstash.RubyUtil; + +import static org.junit.Assert.*; + +// Porting to Java of logstash-core/spec/logstash/settings/port_range_spec.rb +public class SettingPortRangeTest { + + private static void assertThrowsError(String expectedErrorMessage, Runnable action) { + try { + action.run(); + fail("An error must be thrown"); + } catch (IllegalArgumentException ex) { + assertTrue(ex.getMessage().contains(expectedErrorMessage)); + } + } + + @Test + public void givenPortRangeCreatedWithSingleIntegerValue_thenCoercesTheValueToRange() { + SettingPortRange sut = new SettingPortRange("test", 9_000); + assertEquals(new Range<>(9_000, 9_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithSingleIntegerValue_thenCanUpdateTheRange() { + SettingPortRange sut = new SettingPortRange("test", 9_000); + sut.set(10_000); + assertEquals(new Range<>(10_000, 10_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithStringValue_thenCoercesTheValueToRange() { + SettingPortRange sut = new SettingPortRange("test", "9000-10000"); + assertEquals(new Range<>(9_000, 10_000), sut.value()); + sut = new SettingPortRange("test", " 9000-10000 "); + assertEquals(new Range<>(9_000, 10_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithStringValue_whenUpperPortIsOutOfRange_thenThrowsAnError() { + assertThrowsError("valid options are within the range of 1-65535", + () -> new SettingPortRange("test", "9000-95000") + ); + } + + @Test + public void givenPortRangeCreatedWithStringValue_thenCanUpdateTheRange() { + SettingPortRange sut = new SettingPortRange("test", "9000-10000"); + sut.set("500-1000"); + assertEquals(new Range<>(500, 1000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithGarbageString_thenThrowsAnError() { + assertThrowsError("Could not coerce [fsdfnsdkjnfjs](type: class java.lang.String) into a port range", + () -> new SettingPortRange("test", "fsdfnsdkjnfjs") + ); + } + + @Test + public void givenPortRange_whenUpdatedWithGarbageString_thenThrowsAnError() { + final SettingPortRange sut = new SettingPortRange("test", 10_000); + assertThrowsError("Could not coerce [dsfnsdknfksdnfjksdnfjns](type: class java.lang.String) into a port range", + () -> sut.set("dsfnsdknfksdnfjksdnfjns") + ); + } + + @Test + public void givenPortRangeCreatedWithUnknownType_thenThrowsAnError() { + assertThrowsError("Could not coerce [0.1](type: class java.lang.Double) into a port range", + () -> new SettingPortRange("test", 0.1) + ); + } + + @Test + public void givenPortRange_whenUpdatedWithUnknownType_thenThrowsAnError() { + final SettingPortRange sut = new SettingPortRange("test", 10_000); + assertThrowsError("Could not coerce [0.1](type: class java.lang.Double) into a port range", + () -> sut.set(0.1) + ); + } + + @Test + public void givenPortRangeCreatedWithRangeValue_thenCoercesTheValueToRange() { + SettingPortRange sut = new SettingPortRange("test", new Range<>(9_000, 10_000)); + assertEquals(new Range<>(9_000, 10_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithRubyRangeValue_thenCoercesTheValueToRange() { + ThreadContext ctx = RubyUtil.RUBY.getCurrentContext(); + RubyRange rubyRange = RubyRange.newExclusiveRange(ctx, new RubyFixnum(RubyUtil.RUBY, 9_000), new RubyFixnum(RubyUtil.RUBY, 10_000)); + SettingPortRange sut = new SettingPortRange("test", rubyRange); + assertEquals(new Range<>(9_000, 10_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithRangeValue_thenCanUpdateTheRange() { + SettingPortRange sut = new SettingPortRange("test", new Range<>(9_000, 10_000)); + sut.set(new Range<>(500, 1_000)); + assertEquals(new Range<>(500, 1_000), sut.value()); + } + + @Test + public void givenPortRangeCreatedWithOutOfRangeUpperPort_thenThrowsAnError() { + assertThrowsError("valid options are within the range of 1-65535", + () -> new SettingPortRange("test", new Range<>(9_000, 90_000)) + ); + } + + @Test + public void givenPortRangeCreatedWithOutOfRangePort_thenThrowsAnError() { + assertThrowsError("valid options are within the range of 1-65535", + () -> new SettingPortRange("test", new Range<>(-1_000, 1_000)) + ); + } +} \ No newline at end of file From fbd6ca2b73aa22c52ed674809de043abc10658b8 Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 9 Sep 2025 15:52:04 +0200 Subject: [PATCH 10/15] Updated coerce to trim whitespaces when coercing from String and added ability to accept also JRuby's RubyRange instances --- .../org/logstash/settings/SettingPortRange.java | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java index d3f5cdbd2d0..aac5689be83 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java +++ b/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java @@ -19,6 +19,10 @@ package org.logstash.settings; +import org.jruby.RubyInteger; +import org.jruby.RubyRange; +import org.logstash.RubyUtil; + // Ideally would be a Coercible>, but given the fact that // values can be effectively coerced into the constructor, it needs instances // of Objects to represent Integer, String, Long to be later coerced into Range. @@ -40,7 +44,6 @@ public static boolean isValid(Object range) { return VALID_PORT_RANGE.contains((Range) range); } - // TODO cover with tests @Override public Range coerce(Object obj) { if (obj instanceof Range) { @@ -58,7 +61,7 @@ public Range coerce(Object obj) { } if (obj instanceof String) { - String val = (String) obj; + String val = ((String) obj).trim(); String[] parts = val.split(PORT_SEPARATOR); String firstStr = parts[0]; String lastStr; @@ -75,6 +78,13 @@ public Range coerce(Object obj) { throw new IllegalArgumentException("Could not coerce [" + obj + "](type: " + obj.getClass() + ") into a port range"); } } + + if (obj instanceof RubyRange) { + RubyRange rubyRange = (RubyRange) obj; + RubyInteger begin = rubyRange.begin(RubyUtil.RUBY.getCurrentContext()).convertToInteger(); + RubyInteger end = rubyRange.end(RubyUtil.RUBY.getCurrentContext()).convertToInteger(); + return new Range<>(begin.getIntValue(), end.getIntValue()); + } throw new IllegalArgumentException("Could not coerce [" + obj + "](type: " + obj.getClass() + ") into a port range"); } From 194ad7dfbd184afbb7e583b0ebe5432b2389467e Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 9 Sep 2025 17:25:31 +0200 Subject: [PATCH 11/15] [Test] Given that SettingPortRange cna handle also JRuby RubyRange avoid the creation of Java Range class --- logstash-core/lib/logstash/environment.rb | 2 +- logstash-core/spec/logstash/settings/port_range_spec.rb | 8 ++++---- logstash-core/spec/logstash/settings_spec.rb | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/logstash-core/lib/logstash/environment.rb b/logstash-core/lib/logstash/environment.rb index 7e7f243fd04..3c08e6d2b90 100644 --- a/logstash-core/lib/logstash/environment.rb +++ b/logstash-core/lib/logstash/environment.rb @@ -71,7 +71,7 @@ def self.as_java_range(r) Setting::Boolean.new("log.format.json.fix_duplicate_message_fields", true), Setting::Boolean.new("api.enabled", true), Setting::SettingString.new("api.http.host", "127.0.0.1"), - Setting::PortRange.new("api.http.port", ::LogStash.as_java_range(9600..9700)), + Setting::PortRange.new("api.http.port", 9600..9700), Setting::SettingString.new("api.environment", "production"), Setting::SettingString.new("api.auth.type", "none", true, %w(none basic)), Setting::SettingString.new("api.auth.basic.username", nil, false).nullable, diff --git a/logstash-core/spec/logstash/settings/port_range_spec.rb b/logstash-core/spec/logstash/settings/port_range_spec.rb index 4d257776546..7c0b50c6645 100644 --- a/logstash-core/spec/logstash/settings/port_range_spec.rb +++ b/logstash-core/spec/logstash/settings/port_range_spec.rb @@ -82,23 +82,23 @@ end context "When value is a range" do - subject { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(9000..10000)) } + subject { LogStash::Setting::PortRange.new("mynewtest", 9000..10000) } it "accepts a ruby range as the default value" do expect { subject }.not_to raise_error end it "can update the range" do - subject.set(::LogStash.as_java_range(500..1000)) + subject.set(500..1000) expect(subject.value).to eq(::LogStash.as_java_range(500..1000)) end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(9000..1000000)) }.to raise_error + expect { LogStash::Setting::PortRange.new("mynewtest", 9000..1000000) }.to raise_error end it "raise an exception on when port are out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", ::LogStash.as_java_range(-1000..1000)) }.to raise_error + expect { LogStash::Setting::PortRange.new("mynewtest", -1000..1000) }.to raise_error end end end diff --git a/logstash-core/spec/logstash/settings_spec.rb b/logstash-core/spec/logstash/settings_spec.rb index 09dfc018278..afd0ed630a1 100644 --- a/logstash-core/spec/logstash/settings_spec.rb +++ b/logstash-core/spec/logstash/settings_spec.rb @@ -64,7 +64,7 @@ describe "#to_hash" do let(:java_deprecated_alias) { LogStash::Setting::Boolean.new("java.actual", true).with_deprecated_alias("java.deprecated") } - let(:ruby_deprecated_alias) { LogStash::Setting::PortRange.new("ruby.actual", ::LogStash.as_java_range(9600..9700)).with_deprecated_alias("ruby.deprecated") } + let(:ruby_deprecated_alias) { LogStash::Setting::PortRange.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } let(:non_deprecated) { LogStash::Setting::Boolean.new("plain_setting", false) } before :each do From d241192c9c9f0f6555f3b46566fd87408fe86a74 Mon Sep 17 00:00:00 2001 From: andsel Date: Wed, 10 Sep 2025 13:09:20 +0200 Subject: [PATCH 12/15] Removed aliasing of PortRange (Ruby class) with SettingPortRange (Java class) --- logstash-core/lib/logstash/environment.rb | 2 +- logstash-core/lib/logstash/settings.rb | 56 +------------------ .../spec/logstash/settings/port_range_spec.rb | 22 ++++---- logstash-core/spec/logstash/settings_spec.rb | 2 +- 4 files changed, 15 insertions(+), 67 deletions(-) diff --git a/logstash-core/lib/logstash/environment.rb b/logstash-core/lib/logstash/environment.rb index 3c08e6d2b90..dea3994c8a1 100644 --- a/logstash-core/lib/logstash/environment.rb +++ b/logstash-core/lib/logstash/environment.rb @@ -71,7 +71,7 @@ def self.as_java_range(r) Setting::Boolean.new("log.format.json.fix_duplicate_message_fields", true), Setting::Boolean.new("api.enabled", true), Setting::SettingString.new("api.http.host", "127.0.0.1"), - Setting::PortRange.new("api.http.port", 9600..9700), + Setting::SettingPortRange.new("api.http.port", 9600..9700), Setting::SettingString.new("api.environment", "production"), Setting::SettingString.new("api.auth.type", "none", true, %w(none basic)), Setting::SettingString.new("api.auth.basic.username", nil, false).nullable, diff --git a/logstash-core/lib/logstash/settings.rb b/logstash-core/lib/logstash/settings.rb index fb5f1123bee..140cbd56df2 100644 --- a/logstash-core/lib/logstash/settings.rb +++ b/logstash-core/lib/logstash/settings.rb @@ -419,61 +419,9 @@ def coerce(value) java_import org.logstash.settings.SettingPositiveInteger - # java_import org.logstash.settings.SettingPort - Port = org::logstash::settings::SettingPort + java_import org.logstash.settings.SettingPort # seems unused - # class Port < SettingInteger - # VALID_PORT_RANGE = 1..65535 - # - # def initialize(name, default = nil, strict = true) - # super(name, default, strict) { |value| valid?(value) } - # end - # - # def valid?(port) - # VALID_PORT_RANGE.cover?(port) - # end - # end - - # java_import org.logstash.settings.SettingPortRange - PortRange = org::logstash::settings::SettingPortRange - - # class PortRange < Coercible - # PORT_SEPARATOR = "-" - # VALID_PORT_RANGE = 1..65535 - # - # def initialize(name, default = nil, strict = true) - # super(name, ::Range, default, strict = true) { |value| valid?(value) } - # end - # - # def valid?(range) - # VALID_PORT_RANGE.first <= range.first && VALID_PORT_RANGE.last >= range.last - # end - # - # def coerce(value) - # case value - # when ::Range - # value - # when ::Integer - # value..value - # when ::String - # first, last = value.split(PORT_SEPARATOR) - # last = first if last.nil? - # begin - # (Integer(first))..(Integer(last)) - # rescue ArgumentError # Trap and reraise a more human error - # raise ArgumentError.new("Could not coerce #{value} into a port range") - # end - # else - # raise ArgumentError.new("Could not coerce #{value} into a port range") - # end - # end - # - # def validate(value) - # unless valid?(value) - # raise ArgumentError.new("Invalid value \"#{name}: #{value}\", valid options are within the range of #{Port::VALID_PORT_RANGE.first}-#{Port::VALID_PORT_RANGE.last}") - # end - # end - # end + java_import org.logstash.settings.SettingPortRange class Validator < Setting def initialize(name, default = nil, strict = true, validator_class = nil) diff --git a/logstash-core/spec/logstash/settings/port_range_spec.rb b/logstash-core/spec/logstash/settings/port_range_spec.rb index 7c0b50c6645..47e3509de8e 100644 --- a/logstash-core/spec/logstash/settings/port_range_spec.rb +++ b/logstash-core/spec/logstash/settings/port_range_spec.rb @@ -18,9 +18,9 @@ require "logstash/settings" require "spec_helper" -describe LogStash::Setting::PortRange do +describe LogStash::Setting::SettingPortRange do context "When the value is an Integer" do - subject { LogStash::Setting::PortRange.new("mynewtest", 9000) } + subject { LogStash::Setting::SettingPortRange.new("mynewtest", 9000) } it "coerces the value in a range" do expect { subject }.not_to raise_error @@ -37,14 +37,14 @@ end context "When the value is a string" do - subject { LogStash::Setting::PortRange.new("mynewtest", "9000-10000") } + subject { LogStash::Setting::SettingPortRange.new("mynewtest", "9000-10000") } it "coerces a string range with the format (9000-10000)" do expect { subject }.not_to raise_error end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", "1000-95000") }.to raise_error + expect { LogStash::Setting::SettingPortRange.new("mynewtest", "1000-95000") }.to raise_error end it "returns a range" do @@ -58,31 +58,31 @@ end context "when the value is a garbage string" do - subject { LogStash::Setting::PortRange.new("mynewtest", "fsdfnsdkjnfjs") } + subject { LogStash::Setting::SettingPortRange.new("mynewtest", "fsdfnsdkjnfjs") } it "raises an argument error" do expect { subject }.to raise_error end it "raises an exception on update" do - expect { LogStash::Setting::PortRange.new("mynewtest", 10000).set("dsfnsdknfksdnfjksdnfjns") }.to raise_error + expect { LogStash::Setting::SettingPortRange.new("mynewtest", 10000).set("dsfnsdknfksdnfjksdnfjns") }.to raise_error end end context "when the value is an unknown type" do - subject { LogStash::Setting::PortRange.new("mynewtest", 0.1) } + subject { LogStash::Setting::SettingPortRange.new("mynewtest", 0.1) } it "raises an argument error" do expect { subject }.to raise_error end it "raises an exception on update" do - expect { LogStash::Setting::PortRange.new("mynewtest", 10000).set(0.1) }.to raise_error + expect { LogStash::Setting::SettingPortRange.new("mynewtest", 10000).set(0.1) }.to raise_error end end context "When value is a range" do - subject { LogStash::Setting::PortRange.new("mynewtest", 9000..10000) } + subject { LogStash::Setting::SettingPortRange.new("mynewtest", 9000..10000) } it "accepts a ruby range as the default value" do expect { subject }.not_to raise_error @@ -94,11 +94,11 @@ end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", 9000..1000000) }.to raise_error + expect { LogStash::Setting::SettingPortRange.new("mynewtest", 9000..1000000) }.to raise_error end it "raise an exception on when port are out of range" do - expect { LogStash::Setting::PortRange.new("mynewtest", -1000..1000) }.to raise_error + expect { LogStash::Setting::SettingPortRange.new("mynewtest", -1000..1000) }.to raise_error end end end diff --git a/logstash-core/spec/logstash/settings_spec.rb b/logstash-core/spec/logstash/settings_spec.rb index afd0ed630a1..a9d99f7c9cf 100644 --- a/logstash-core/spec/logstash/settings_spec.rb +++ b/logstash-core/spec/logstash/settings_spec.rb @@ -64,7 +64,7 @@ describe "#to_hash" do let(:java_deprecated_alias) { LogStash::Setting::Boolean.new("java.actual", true).with_deprecated_alias("java.deprecated") } - let(:ruby_deprecated_alias) { LogStash::Setting::PortRange.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } + let(:ruby_deprecated_alias) { LogStash::Setting::SettingPortRange.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } let(:non_deprecated) { LogStash::Setting::Boolean.new("plain_setting", false) } before :each do From 52a6da2f3e53aeb1c049955602a2db66063141b6 Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 16 Sep 2025 12:58:05 +0200 Subject: [PATCH 13/15] Renamed SettingPortRange to PortRangeSetting --- logstash-core/lib/logstash/environment.rb | 2 +- logstash-core/lib/logstash/settings.rb | 2 +- .../spec/logstash/settings/port_range_spec.rb | 22 ++++++------- logstash-core/spec/logstash/settings_spec.rb | 2 +- ...ngPortRange.java => PortRangeSetting.java} | 6 ++-- ...ngeTest.java => PortRangeSettingTest.java} | 32 +++++++++---------- 6 files changed, 33 insertions(+), 33 deletions(-) rename logstash-core/src/main/java/org/logstash/settings/{SettingPortRange.java => PortRangeSetting.java} (95%) rename logstash-core/src/test/java/org/logstash/settings/{SettingPortRangeTest.java => PortRangeSettingTest.java} (82%) diff --git a/logstash-core/lib/logstash/environment.rb b/logstash-core/lib/logstash/environment.rb index dea3994c8a1..af458abc484 100644 --- a/logstash-core/lib/logstash/environment.rb +++ b/logstash-core/lib/logstash/environment.rb @@ -71,7 +71,7 @@ def self.as_java_range(r) Setting::Boolean.new("log.format.json.fix_duplicate_message_fields", true), Setting::Boolean.new("api.enabled", true), Setting::SettingString.new("api.http.host", "127.0.0.1"), - Setting::SettingPortRange.new("api.http.port", 9600..9700), + Setting::PortRangeSetting.new("api.http.port", 9600..9700), Setting::SettingString.new("api.environment", "production"), Setting::SettingString.new("api.auth.type", "none", true, %w(none basic)), Setting::SettingString.new("api.auth.basic.username", nil, false).nullable, diff --git a/logstash-core/lib/logstash/settings.rb b/logstash-core/lib/logstash/settings.rb index 140cbd56df2..9399c86b7e5 100644 --- a/logstash-core/lib/logstash/settings.rb +++ b/logstash-core/lib/logstash/settings.rb @@ -421,7 +421,7 @@ def coerce(value) java_import org.logstash.settings.SettingPort # seems unused - java_import org.logstash.settings.SettingPortRange + java_import org.logstash.settings.PortRangeSetting class Validator < Setting def initialize(name, default = nil, strict = true, validator_class = nil) diff --git a/logstash-core/spec/logstash/settings/port_range_spec.rb b/logstash-core/spec/logstash/settings/port_range_spec.rb index 47e3509de8e..bc522abf85a 100644 --- a/logstash-core/spec/logstash/settings/port_range_spec.rb +++ b/logstash-core/spec/logstash/settings/port_range_spec.rb @@ -18,9 +18,9 @@ require "logstash/settings" require "spec_helper" -describe LogStash::Setting::SettingPortRange do +describe LogStash::Setting::PortRangeSetting do context "When the value is an Integer" do - subject { LogStash::Setting::SettingPortRange.new("mynewtest", 9000) } + subject { LogStash::Setting::PortRangeSetting.new("mynewtest", 9000) } it "coerces the value in a range" do expect { subject }.not_to raise_error @@ -37,14 +37,14 @@ end context "When the value is a string" do - subject { LogStash::Setting::SettingPortRange.new("mynewtest", "9000-10000") } + subject { LogStash::Setting::PortRangeSetting.new("mynewtest", "9000-10000") } it "coerces a string range with the format (9000-10000)" do expect { subject }.not_to raise_error end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::SettingPortRange.new("mynewtest", "1000-95000") }.to raise_error + expect { LogStash::Setting::PortRangeSetting.new("mynewtest", "1000-95000") }.to raise_error end it "returns a range" do @@ -58,31 +58,31 @@ end context "when the value is a garbage string" do - subject { LogStash::Setting::SettingPortRange.new("mynewtest", "fsdfnsdkjnfjs") } + subject { LogStash::Setting::PortRangeSetting.new("mynewtest", "fsdfnsdkjnfjs") } it "raises an argument error" do expect { subject }.to raise_error end it "raises an exception on update" do - expect { LogStash::Setting::SettingPortRange.new("mynewtest", 10000).set("dsfnsdknfksdnfjksdnfjns") }.to raise_error + expect { LogStash::Setting::PortRangeSetting.new("mynewtest", 10000).set("dsfnsdknfksdnfjksdnfjns") }.to raise_error end end context "when the value is an unknown type" do - subject { LogStash::Setting::SettingPortRange.new("mynewtest", 0.1) } + subject { LogStash::Setting::PortRangeSetting.new("mynewtest", 0.1) } it "raises an argument error" do expect { subject }.to raise_error end it "raises an exception on update" do - expect { LogStash::Setting::SettingPortRange.new("mynewtest", 10000).set(0.1) }.to raise_error + expect { LogStash::Setting::PortRangeSetting.new("mynewtest", 10000).set(0.1) }.to raise_error end end context "When value is a range" do - subject { LogStash::Setting::SettingPortRange.new("mynewtest", 9000..10000) } + subject { LogStash::Setting::PortRangeSetting.new("mynewtest", 9000..10000) } it "accepts a ruby range as the default value" do expect { subject }.not_to raise_error @@ -94,11 +94,11 @@ end it "refuses when then upper port is out of range" do - expect { LogStash::Setting::SettingPortRange.new("mynewtest", 9000..1000000) }.to raise_error + expect { LogStash::Setting::PortRangeSetting.new("mynewtest", 9000..1000000) }.to raise_error end it "raise an exception on when port are out of range" do - expect { LogStash::Setting::SettingPortRange.new("mynewtest", -1000..1000) }.to raise_error + expect { LogStash::Setting::PortRangeSetting.new("mynewtest", -1000..1000) }.to raise_error end end end diff --git a/logstash-core/spec/logstash/settings_spec.rb b/logstash-core/spec/logstash/settings_spec.rb index a9d99f7c9cf..33d7b8d3cb9 100644 --- a/logstash-core/spec/logstash/settings_spec.rb +++ b/logstash-core/spec/logstash/settings_spec.rb @@ -64,7 +64,7 @@ describe "#to_hash" do let(:java_deprecated_alias) { LogStash::Setting::Boolean.new("java.actual", true).with_deprecated_alias("java.deprecated") } - let(:ruby_deprecated_alias) { LogStash::Setting::SettingPortRange.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } + let(:ruby_deprecated_alias) { LogStash::Setting::PortRangeSetting.new("ruby.actual", 9600..9700).with_deprecated_alias("ruby.deprecated") } let(:non_deprecated) { LogStash::Setting::Boolean.new("plain_setting", false) } before :each do diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java b/logstash-core/src/main/java/org/logstash/settings/PortRangeSetting.java similarity index 95% rename from logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java rename to logstash-core/src/main/java/org/logstash/settings/PortRangeSetting.java index aac5689be83..b31882994ae 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPortRange.java +++ b/logstash-core/src/main/java/org/logstash/settings/PortRangeSetting.java @@ -27,13 +27,13 @@ // values can be effectively coerced into the constructor, it needs instances // of Objects to represent Integer, String, Long to be later coerced into Range. @SuppressWarnings({"rawtypes", "unchecked"}) -public class SettingPortRange extends Coercible { +public class PortRangeSetting extends Coercible { private static final Range VALID_PORT_RANGE = new Range<>(1, 65535); public static final String PORT_SEPARATOR = "-"; - public SettingPortRange(String name, Object defaultValue) { - super(name, defaultValue, true, SettingPortRange::isValid); + public PortRangeSetting(String name, Object defaultValue) { + super(name, defaultValue, true, PortRangeSetting::isValid); } public static boolean isValid(Object range) { diff --git a/logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java b/logstash-core/src/test/java/org/logstash/settings/PortRangeSettingTest.java similarity index 82% rename from logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java rename to logstash-core/src/test/java/org/logstash/settings/PortRangeSettingTest.java index 953dced5e5e..3b32887d845 100644 --- a/logstash-core/src/test/java/org/logstash/settings/SettingPortRangeTest.java +++ b/logstash-core/src/test/java/org/logstash/settings/PortRangeSettingTest.java @@ -28,7 +28,7 @@ import static org.junit.Assert.*; // Porting to Java of logstash-core/spec/logstash/settings/port_range_spec.rb -public class SettingPortRangeTest { +public class PortRangeSettingTest { private static void assertThrowsError(String expectedErrorMessage, Runnable action) { try { @@ -41,35 +41,35 @@ private static void assertThrowsError(String expectedErrorMessage, Runnable acti @Test public void givenPortRangeCreatedWithSingleIntegerValue_thenCoercesTheValueToRange() { - SettingPortRange sut = new SettingPortRange("test", 9_000); + PortRangeSetting sut = new PortRangeSetting("test", 9_000); assertEquals(new Range<>(9_000, 9_000), sut.value()); } @Test public void givenPortRangeCreatedWithSingleIntegerValue_thenCanUpdateTheRange() { - SettingPortRange sut = new SettingPortRange("test", 9_000); + PortRangeSetting sut = new PortRangeSetting("test", 9_000); sut.set(10_000); assertEquals(new Range<>(10_000, 10_000), sut.value()); } @Test public void givenPortRangeCreatedWithStringValue_thenCoercesTheValueToRange() { - SettingPortRange sut = new SettingPortRange("test", "9000-10000"); + PortRangeSetting sut = new PortRangeSetting("test", "9000-10000"); assertEquals(new Range<>(9_000, 10_000), sut.value()); - sut = new SettingPortRange("test", " 9000-10000 "); + sut = new PortRangeSetting("test", " 9000-10000 "); assertEquals(new Range<>(9_000, 10_000), sut.value()); } @Test public void givenPortRangeCreatedWithStringValue_whenUpperPortIsOutOfRange_thenThrowsAnError() { assertThrowsError("valid options are within the range of 1-65535", - () -> new SettingPortRange("test", "9000-95000") + () -> new PortRangeSetting("test", "9000-95000") ); } @Test public void givenPortRangeCreatedWithStringValue_thenCanUpdateTheRange() { - SettingPortRange sut = new SettingPortRange("test", "9000-10000"); + PortRangeSetting sut = new PortRangeSetting("test", "9000-10000"); sut.set("500-1000"); assertEquals(new Range<>(500, 1000), sut.value()); } @@ -77,13 +77,13 @@ public void givenPortRangeCreatedWithStringValue_thenCanUpdateTheRange() { @Test public void givenPortRangeCreatedWithGarbageString_thenThrowsAnError() { assertThrowsError("Could not coerce [fsdfnsdkjnfjs](type: class java.lang.String) into a port range", - () -> new SettingPortRange("test", "fsdfnsdkjnfjs") + () -> new PortRangeSetting("test", "fsdfnsdkjnfjs") ); } @Test public void givenPortRange_whenUpdatedWithGarbageString_thenThrowsAnError() { - final SettingPortRange sut = new SettingPortRange("test", 10_000); + final PortRangeSetting sut = new PortRangeSetting("test", 10_000); assertThrowsError("Could not coerce [dsfnsdknfksdnfjksdnfjns](type: class java.lang.String) into a port range", () -> sut.set("dsfnsdknfksdnfjksdnfjns") ); @@ -92,13 +92,13 @@ public void givenPortRange_whenUpdatedWithGarbageString_thenThrowsAnError() { @Test public void givenPortRangeCreatedWithUnknownType_thenThrowsAnError() { assertThrowsError("Could not coerce [0.1](type: class java.lang.Double) into a port range", - () -> new SettingPortRange("test", 0.1) + () -> new PortRangeSetting("test", 0.1) ); } @Test public void givenPortRange_whenUpdatedWithUnknownType_thenThrowsAnError() { - final SettingPortRange sut = new SettingPortRange("test", 10_000); + final PortRangeSetting sut = new PortRangeSetting("test", 10_000); assertThrowsError("Could not coerce [0.1](type: class java.lang.Double) into a port range", () -> sut.set(0.1) ); @@ -106,7 +106,7 @@ public void givenPortRange_whenUpdatedWithUnknownType_thenThrowsAnError() { @Test public void givenPortRangeCreatedWithRangeValue_thenCoercesTheValueToRange() { - SettingPortRange sut = new SettingPortRange("test", new Range<>(9_000, 10_000)); + PortRangeSetting sut = new PortRangeSetting("test", new Range<>(9_000, 10_000)); assertEquals(new Range<>(9_000, 10_000), sut.value()); } @@ -114,13 +114,13 @@ public void givenPortRangeCreatedWithRangeValue_thenCoercesTheValueToRange() { public void givenPortRangeCreatedWithRubyRangeValue_thenCoercesTheValueToRange() { ThreadContext ctx = RubyUtil.RUBY.getCurrentContext(); RubyRange rubyRange = RubyRange.newExclusiveRange(ctx, new RubyFixnum(RubyUtil.RUBY, 9_000), new RubyFixnum(RubyUtil.RUBY, 10_000)); - SettingPortRange sut = new SettingPortRange("test", rubyRange); + PortRangeSetting sut = new PortRangeSetting("test", rubyRange); assertEquals(new Range<>(9_000, 10_000), sut.value()); } @Test public void givenPortRangeCreatedWithRangeValue_thenCanUpdateTheRange() { - SettingPortRange sut = new SettingPortRange("test", new Range<>(9_000, 10_000)); + PortRangeSetting sut = new PortRangeSetting("test", new Range<>(9_000, 10_000)); sut.set(new Range<>(500, 1_000)); assertEquals(new Range<>(500, 1_000), sut.value()); } @@ -128,14 +128,14 @@ public void givenPortRangeCreatedWithRangeValue_thenCanUpdateTheRange() { @Test public void givenPortRangeCreatedWithOutOfRangeUpperPort_thenThrowsAnError() { assertThrowsError("valid options are within the range of 1-65535", - () -> new SettingPortRange("test", new Range<>(9_000, 90_000)) + () -> new PortRangeSetting("test", new Range<>(9_000, 90_000)) ); } @Test public void givenPortRangeCreatedWithOutOfRangePort_thenThrowsAnError() { assertThrowsError("valid options are within the range of 1-65535", - () -> new SettingPortRange("test", new Range<>(-1_000, 1_000)) + () -> new PortRangeSetting("test", new Range<>(-1_000, 1_000)) ); } } \ No newline at end of file From 47c5d6b5b68f6935ad6026332ceeba5aed88570e Mon Sep 17 00:00:00 2001 From: andsel Date: Tue, 16 Sep 2025 13:38:31 +0200 Subject: [PATCH 14/15] Renamed SettingPort to PortSetting --- logstash-core/lib/logstash/settings.rb | 2 +- .../settings/{SettingPort.java => PortSetting.java} | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) rename logstash-core/src/main/java/org/logstash/settings/{SettingPort.java => PortSetting.java} (85%) diff --git a/logstash-core/lib/logstash/settings.rb b/logstash-core/lib/logstash/settings.rb index 9399c86b7e5..6b8006b8504 100644 --- a/logstash-core/lib/logstash/settings.rb +++ b/logstash-core/lib/logstash/settings.rb @@ -419,7 +419,7 @@ def coerce(value) java_import org.logstash.settings.SettingPositiveInteger - java_import org.logstash.settings.SettingPort # seems unused + java_import org.logstash.settings.PortSetting # seems unused java_import org.logstash.settings.PortRangeSetting diff --git a/logstash-core/src/main/java/org/logstash/settings/SettingPort.java b/logstash-core/src/main/java/org/logstash/settings/PortSetting.java similarity index 85% rename from logstash-core/src/main/java/org/logstash/settings/SettingPort.java rename to logstash-core/src/main/java/org/logstash/settings/PortSetting.java index b1d93ea217c..ce72b512c76 100644 --- a/logstash-core/src/main/java/org/logstash/settings/SettingPort.java +++ b/logstash-core/src/main/java/org/logstash/settings/PortSetting.java @@ -21,7 +21,7 @@ import java.util.function.Predicate; -public final class SettingPort extends SettingInteger { +public final class PortSetting extends SettingInteger { public static final Predicate VALID_PORT_RANGE = new Predicate<>() { @Override @@ -30,15 +30,15 @@ public boolean test(Integer integer) { } }; - public SettingPort(String name, Integer defaultValue) { + public PortSetting(String name, Integer defaultValue) { super(name, defaultValue); } - public SettingPort(String name, Integer defaultValue, boolean strict) { + public PortSetting(String name, Integer defaultValue, boolean strict) { this(name, defaultValue, strict, VALID_PORT_RANGE); } - protected SettingPort(String name, Integer defaultValue, boolean strict, Predicate validator) { + protected PortSetting(String name, Integer defaultValue, boolean strict, Predicate validator) { super(name, defaultValue, strict, validator); } From d9f442b5b9adfb0c86c348f60cd43cc947573f08 Mon Sep 17 00:00:00 2001 From: Andrea Selva Date: Tue, 16 Sep 2025 18:33:57 +0200 Subject: [PATCH 15/15] Fix spacing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: João Duarte --- logstash-core/src/main/java/org/logstash/settings/Range.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/logstash-core/src/main/java/org/logstash/settings/Range.java b/logstash-core/src/main/java/org/logstash/settings/Range.java index 5a00a270980..761afec8e03 100644 --- a/logstash-core/src/main/java/org/logstash/settings/Range.java +++ b/logstash-core/src/main/java/org/logstash/settings/Range.java @@ -29,7 +29,7 @@ public class Range { public Range(T first, T last) { this.first = Objects.requireNonNull(first); - this.last =Objects.requireNonNull(last); + this.last = Objects.requireNonNull(last); if (first.compareTo(last) > 0) { throw new IllegalArgumentException("First must be less than or equal to last"); }