Move Port and PortRange Ruby settings to Java

logstash-core/lib/logstash/environment.rb

@@ -33,6 +33,10 @@ module Environment
     end
   end
 
+  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
+
   [
            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::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,

logstash-core/lib/logstash/settings.rb

@@ -418,55 +418,10 @@ 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
-
-    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
 
-      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.SettingPort # seems unused
 
-      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)

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)

logstash-core/spec/logstash/settings/port_range_spec.rb

@@ -18,87 +18,87 @@
 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
     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
 
   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
-      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
 
   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
     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
 
     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

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

logstash-core/src/main/java/org/logstash/settings/Range.java

@@ -0,0 +1,86 @@
+/*
+ * 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;
+import java.util.function.BiConsumer;
+
+public class Range<T extends Integer> {
+
+    private final T first;
+    private final T last;
+
+    public Range(T first, T 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<T> other) {
+        return first.compareTo(other.first) <= 0 && last.compareTo(other.last) >= 0;
+    }
+
+    public T getFirst() {
+        return first;
+    }
+
+    public T getLast() {
+        return last;
+    }
+
+    public void eachWithIndex(BiConsumer<Integer, Integer> 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(); value < last.intValue(); value++) {
+            consumer.accept(value, index++);
+        }
+    }
+
+    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);
+    }
+}

logstash-core/src/main/java/org/logstash/settings/SettingPort.java

@@ -0,0 +1,49 @@
+/*
+ * 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;
+
+public final class SettingPort extends SettingInteger {
+
+    public static final Predicate<Integer> 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<Integer> validator) {
+        super(name, defaultValue, strict, validator);
+    }
+
+    public static boolean isValid(int port) {
+        return 1 <= port && port <= 65535;
+    }
+
+}