Merge remote-tracking branch 'upstream/main' into entitlements/missing-url-connection-2

ldematte · ldematte · commit 707cff4b0b86 · 2025-03-03T08:51:40.000+01:00
diff --git a/libs/cli/build.gradle b/libs/cli/build.gradle
@@ -12,6 +12,7 @@ apply plugin: 'elasticsearch.publish'
 dependencies {
   api 'net.sf.jopt-simple:jopt-simple:5.0.2'
   api project(':libs:core')
+  api project(':libs:logging')
 
   testImplementation(project(":test:framework")) {
     exclude group: 'org.elasticsearch', module: 'cli'
diff --git a/libs/cli/src/main/java/module-info.java b/libs/cli/src/main/java/module-info.java
@@ -11,6 +11,8 @@
 module org.elasticsearch.cli {
     requires jopt.simple;
     requires org.elasticsearch.base;
+    requires java.logging;
+    requires org.elasticsearch.logging;
 
     exports org.elasticsearch.cli;
 }
diff --git a/libs/cli/src/main/java/org/elasticsearch/cli/Command.java b/libs/cli/src/main/java/org/elasticsearch/cli/Command.java
@@ -15,6 +15,8 @@
 import joptsimple.OptionSpec;
 
 import org.elasticsearch.core.SuppressForbidden;
+import org.elasticsearch.logging.Level;
+import org.elasticsearch.logging.internal.spi.LoggerFactory;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -84,12 +86,16 @@ protected void mainWithoutErrorHandling(String[] args, Terminal terminal, Proces
             return;
         }
 
+        LoggerFactory loggerFactory = LoggerFactory.provider();
         if (options.has(silentOption)) {
             terminal.setVerbosity(Terminal.Verbosity.SILENT);
+            loggerFactory.setRootLevel(Level.OFF);
         } else if (options.has(verboseOption)) {
             terminal.setVerbosity(Terminal.Verbosity.VERBOSE);
+            loggerFactory.setRootLevel(Level.DEBUG);
         } else {
             terminal.setVerbosity(Terminal.Verbosity.NORMAL);
+            loggerFactory.setRootLevel(Level.INFO);
         }
 
         execute(terminal, options, processInfo);
diff --git a/libs/entitlement/src/main/java/org/elasticsearch/entitlement/runtime/policy/entitlements/FilesEntitlement.java b/libs/entitlement/src/main/java/org/elasticsearch/entitlement/runtime/policy/entitlements/FilesEntitlement.java
@@ -91,8 +91,8 @@ static FileData ofRelativePath(Path relativePath, BaseDir baseDir, Mode mode) {
             return new RelativePathFileData(relativePath, baseDir, mode, null, false);
         }
 
-        static FileData ofPathSetting(String setting, BaseDir baseDir, Mode mode, boolean ignoreUrl) {
-            return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, null, false);
+        static FileData ofPathSetting(String setting, BaseDir baseDir, Mode mode) {
+            return new PathSettingFileData(setting, baseDir, mode, null, false);
         }
 
         /**
@@ -220,30 +220,29 @@ public FileData withPlatform(Platform platform) {
         }
     }
 
-    private record PathSettingFileData(String setting, BaseDir baseDir, Mode mode, boolean ignoreUrl, Platform platform, boolean exclusive)
+    private record PathSettingFileData(String setting, BaseDir baseDir, Mode mode, Platform platform, boolean exclusive)
         implements
             RelativeFileData {
 
         @Override
         public PathSettingFileData withExclusive(boolean exclusive) {
-            return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, platform, exclusive);
+            return new PathSettingFileData(setting, baseDir, mode, platform, exclusive);
         }
 
         @Override
         public Stream<Path> resolveRelativePaths(PathLookup pathLookup) {
-            Stream<String> result = pathLookup.settingResolver().apply(setting);
-            if (ignoreUrl) {
-                result = result.filter(s -> s.toLowerCase(Locale.ROOT).startsWith("https://") == false);
-            }
-            return result.map(pathLookup.configDir()::resolve);
+            Stream<String> result = pathLookup.settingResolver()
+                .apply(setting)
+                .filter(s -> s.toLowerCase(Locale.ROOT).startsWith("https://") == false);
+            return result.map(Path::of);
         }
 
         @Override
         public FileData withPlatform(Platform platform) {
             if (platform == platform()) {
                 return this;
             }
-            return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, platform, exclusive);
+            return new PathSettingFileData(setting, baseDir, mode, platform, exclusive);
         }
     }
 
@@ -331,8 +330,6 @@ public static FilesEntitlement build(List<Object> paths) {
             String settingBaseDirAsString = checkString.apply(file, "basedir_if_relative");
             String modeAsString = checkString.apply(file, "mode");
             String platformAsString = checkString.apply(file, "platform");
-            Boolean ignoreUrlAsStringBoolean = checkBoolean.apply(file, "ignore_url");
-            boolean ignoreUrlAsString = ignoreUrlAsStringBoolean != null && ignoreUrlAsStringBoolean;
             Boolean exclusiveBoolean = checkBoolean.apply(file, "exclusive");
             boolean exclusive = exclusiveBoolean != null && exclusiveBoolean;
 
@@ -359,9 +356,6 @@ public static FilesEntitlement build(List<Object> paths) {
                 throw new PolicyValidationException("'relative_to' may only be used with 'relative_path'");
             }
 
-            if (ignoreUrlAsStringBoolean != null && pathSetting == null) {
-                throw new PolicyValidationException("'ignore_url' may only be used with 'path_setting'");
-            }
             if (settingBaseDirAsString != null && pathSetting == null) {
                 throw new PolicyValidationException("'basedir_if_relative' may only be used with 'path_setting'");
             }
@@ -388,7 +382,7 @@ public static FilesEntitlement build(List<Object> paths) {
                     throw new PolicyValidationException("files entitlement with a 'path_setting' must specify 'basedir_if_relative'");
                 }
                 BaseDir baseDir = parseBaseDir(settingBaseDirAsString);
-                fileData = FileData.ofPathSetting(pathSetting, baseDir, mode, ignoreUrlAsString);
+                fileData = FileData.ofPathSetting(pathSetting, baseDir, mode);
             } else {
                 throw new AssertionError("File entry validation error");
             }
diff --git a/libs/entitlement/src/test/java/org/elasticsearch/entitlement/runtime/policy/entitlements/FilesEntitlementTests.java b/libs/entitlement/src/test/java/org/elasticsearch/entitlement/runtime/policy/entitlements/FilesEntitlementTests.java
@@ -101,25 +101,25 @@ public void testPathSettingResolve() {
             List.of(Map.of("path_setting", "foo.bar", "basedir_if_relative", "config", "mode", "read"))
         );
         var filesData = entitlement.filesData();
-        assertThat(filesData, contains(FileData.ofPathSetting("foo.bar", CONFIG, READ, false)));
+        assertThat(filesData, contains(FileData.ofPathSetting("foo.bar", CONFIG, READ)));
 
-        var fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ, false);
+        var fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ);
         // empty settings
         assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), empty());
 
-        fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ, false);
+        fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ);
         settings = Settings.builder().put("foo.bar", "/setting/path").build();
         assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), contains(Path.of("/setting/path")));
 
-        fileData = FileData.ofPathSetting("foo.*.bar", CONFIG, READ, false);
+        fileData = FileData.ofPathSetting("foo.*.bar", CONFIG, READ);
         settings = Settings.builder().put("foo.baz.bar", "/setting/path").build();
         assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), contains(Path.of("/setting/path")));
 
-        fileData = FileData.ofPathSetting("foo.*.bar", CONFIG, READ, false);
+        fileData = FileData.ofPathSetting("foo.*.bar", CONFIG, READ);
         settings = Settings.builder().put("foo.baz.bar", "/setting/path").put("foo.baz2.bar", "/other/path").build();
         assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), containsInAnyOrder(Path.of("/setting/path"), Path.of("/other/path")));
 
-        fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ, false);
+        fileData = FileData.ofPathSetting("foo.bar", CONFIG, READ);
         settings = Settings.builder().put("foo.bar", "relative_path").build();
         assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), contains(Path.of("/config/relative_path")));
     }
@@ -140,28 +140,6 @@ public void testPathSettingBasedirValidation() {
         assertThat(e.getMessage(), is("'basedir_if_relative' may only be used with 'path_setting'"));
     }
 
-    public void testPathSettingIgnoreUrl() {
-        var fileData = FileData.ofPathSetting("foo.*.bar", CONFIG, READ, true);
-        settings = Settings.builder().put("foo.nonurl.bar", "/setting/path").put("foo.url.bar", "https://mysite").build();
-        assertThat(fileData.resolvePaths(TEST_PATH_LOOKUP).toList(), contains(Path.of("/setting/path")));
-    }
-
-    public void testIgnoreUrlValidation() {
-        var e = expectThrows(
-            PolicyValidationException.class,
-            () -> FilesEntitlement.build(List.of(Map.of("path", "/foo", "mode", "read", "ignore_url", true)))
-        );
-        assertThat(e.getMessage(), is("'ignore_url' may only be used with 'path_setting'"));
-
-        e = expectThrows(
-            PolicyValidationException.class,
-            () -> FilesEntitlement.build(
-                List.of(Map.of("relative_path", "foo", "relative_to", "config", "mode", "read", "ignore_url", true))
-            )
-        );
-        assertThat(e.getMessage(), is("'ignore_url' may only be used with 'path_setting'"));
-    }
-
     public void testExclusiveParsing() throws Exception {
         Policy parsedPolicy = new PolicyParser(new ByteArrayInputStream("""
                     entitlement-module-name:
diff --git a/libs/logging/src/main/java/module-info.java b/libs/logging/src/main/java/module-info.java
@@ -9,5 +9,5 @@
 
 module org.elasticsearch.logging {
     exports org.elasticsearch.logging;
-    exports org.elasticsearch.logging.internal.spi to org.elasticsearch.server;
+    exports org.elasticsearch.logging.internal.spi to org.elasticsearch.server, org.elasticsearch.cli;
 }
diff --git a/libs/logging/src/main/java/org/elasticsearch/logging/internal/spi/LoggerFactory.java b/libs/logging/src/main/java/org/elasticsearch/logging/internal/spi/LoggerFactory.java
@@ -9,6 +9,7 @@
 
 package org.elasticsearch.logging.internal.spi;
 
+import org.elasticsearch.logging.Level;
 import org.elasticsearch.logging.Logger;
 
 /**
@@ -26,6 +27,10 @@ public static LoggerFactory provider() {
 
     public abstract Logger getLogger(Class<?> clazz);
 
+    public abstract void setRootLevel(Level level);
+
+    public abstract Level getRootLevel();
+
     public static void setInstance(LoggerFactory INSTANCE) {
         LoggerFactory.INSTANCE = INSTANCE;
     }
diff --git a/modules/repository-s3/src/main/plugin-metadata/entitlement-policy.yaml b/modules/repository-s3/src/main/plugin-metadata/entitlement-policy.yaml
@@ -8,3 +8,8 @@ ALL-UNNAMED:
     - relative_path: ".aws/"
       relative_to: "home"
       mode: "read"
+  # The security policy permission states this is "only for tests": org.elasticsearch.repositories.s3.S3RepositoryPlugin
+  # TODO: check this is actually needed, and if we can isolate it to a test-only policy
+  - write_system_properties:
+      properties:
+        - es.allow_insecure_settings
diff --git a/modules/transport-netty4/src/main/plugin-metadata/entitlement-policy.yaml b/modules/transport-netty4/src/main/plugin-metadata/entitlement-policy.yaml
@@ -2,6 +2,12 @@ io.netty.transport:
   - inbound_network
   - outbound_network
   - manage_threads
+  # Netty NioEventLoop wants to change this, because of https://bugs.openjdk.java.net/browse/JDK-6427854
+  # the bug says it only happened rarely, and that its fixed, but apparently it still happens rarely!
+  # TODO: copied over from the security policy. Check if this is still valid
+  - write_system_properties:
+      properties:
+        - sun.nio.ch.bugLevel
 io.netty.common:
   - inbound_network
   - outbound_network
diff --git a/muted-tests.yml b/muted-tests.yml
@@ -341,9 +341,10 @@ tests:
 - class: org.elasticsearch.xpack.searchablesnapshots.FrozenSearchableSnapshotsIntegTests
   method: testCreateAndRestorePartialSearchableSnapshot
   issue: https://github.com/elastic/elasticsearch/issues/123773
-- class: org.elasticsearch.xpack.esql.action.EsqlActionBreakerIT
-  method: testDropAllColumns
-  issue: https://github.com/elastic/elasticsearch/issues/123791
+
+- class: org.elasticsearch.xpack.test.rest.XPackRestIT
+  method: test {p0=snapshot/10_basic/Create a source only snapshot and then restore it}
+  issue: https://github.com/elastic/elasticsearch/issues/122755
 
 # Examples:
 #
diff --git a/plugins/discovery-azure-classic/src/main/plugin-metadata/entitlement-policy.yaml b/plugins/discovery-azure-classic/src/main/plugin-metadata/entitlement-policy.yaml
@@ -0,0 +1,2 @@
+ALL-UNNAMED:
+  - outbound_network
diff --git a/server/src/main/java/org/elasticsearch/common/logging/internal/LevelUtil.java b/server/src/main/java/org/elasticsearch/common/logging/internal/LevelUtil.java
@@ -9,20 +9,51 @@
 
 package org.elasticsearch.common.logging.internal;
 
+import static org.apache.logging.log4j.Level.ALL;
+import static org.apache.logging.log4j.Level.DEBUG;
+import static org.apache.logging.log4j.Level.ERROR;
+import static org.apache.logging.log4j.Level.FATAL;
+import static org.apache.logging.log4j.Level.INFO;
+import static org.apache.logging.log4j.Level.OFF;
+import static org.apache.logging.log4j.Level.TRACE;
+import static org.apache.logging.log4j.Level.WARN;
+
 public final class LevelUtil {
 
     private LevelUtil() {}
 
     public static org.apache.logging.log4j.Level log4jLevel(final org.elasticsearch.logging.Level level) {
         return switch (level) {
-            case OFF -> org.apache.logging.log4j.Level.OFF;
-            case FATAL -> org.apache.logging.log4j.Level.FATAL;
+            case OFF -> OFF;
+            case FATAL -> FATAL;
             case ERROR -> org.apache.logging.log4j.Level.ERROR;
-            case WARN -> org.apache.logging.log4j.Level.WARN;
+            case WARN -> WARN;
             case INFO -> org.apache.logging.log4j.Level.INFO;
             case DEBUG -> org.apache.logging.log4j.Level.DEBUG;
-            case TRACE -> org.apache.logging.log4j.Level.TRACE;
+            case TRACE -> TRACE;
             case ALL -> org.apache.logging.log4j.Level.ALL;
         };
     }
+
+    public static org.elasticsearch.logging.Level elasticsearchLevel(final org.apache.logging.log4j.Level log4jLevel) {
+        // we can't use a switch because log4j levels are not an enum
+        if (log4jLevel == OFF) {
+            return org.elasticsearch.logging.Level.OFF;
+        } else if (log4jLevel == FATAL) {
+            return org.elasticsearch.logging.Level.FATAL;
+        } else if (log4jLevel == ERROR) {
+            return org.elasticsearch.logging.Level.ERROR;
+        } else if (log4jLevel == WARN) {
+            return org.elasticsearch.logging.Level.WARN;
+        } else if (log4jLevel == INFO) {
+            return org.elasticsearch.logging.Level.INFO;
+        } else if (log4jLevel == DEBUG) {
+            return org.elasticsearch.logging.Level.DEBUG;
+        } else if (log4jLevel == TRACE) {
+            return org.elasticsearch.logging.Level.TRACE;
+        } else if (log4jLevel == ALL) {
+            return org.elasticsearch.logging.Level.ALL;
+        }
+        throw new AssertionError("unknown log4j level [" + log4jLevel + "]");
+    }
 }
diff --git a/server/src/main/java/org/elasticsearch/common/logging/internal/LoggerFactoryImpl.java b/server/src/main/java/org/elasticsearch/common/logging/internal/LoggerFactoryImpl.java
@@ -10,6 +10,8 @@
 package org.elasticsearch.common.logging.internal;
 
 import org.apache.logging.log4j.LogManager;
+import org.elasticsearch.common.logging.Loggers;
+import org.elasticsearch.logging.Level;
 import org.elasticsearch.logging.Logger;
 import org.elasticsearch.logging.internal.spi.LoggerFactory;
 
@@ -30,4 +32,15 @@ public Logger getLogger(Class<?> clazz) {
         // classloader a class comes from, we will use the root logging config.
         return getLogger(clazz.getName());
     }
+
+    @Override
+    public void setRootLevel(Level level) {
+        var log4jLevel = LevelUtil.log4jLevel(level);
+        Loggers.setLevel(LogManager.getRootLogger(), log4jLevel);
+    }
+
+    @Override
+    public Level getRootLevel() {
+        return LevelUtil.elasticsearchLevel(LogManager.getRootLogger().getLevel());
+    }
 }
diff --git a/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java b/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java
@@ -121,6 +121,7 @@
 import org.elasticsearch.indices.IndicesModule;
 import org.elasticsearch.indices.analysis.AnalysisModule;
 import org.elasticsearch.jdk.RuntimeVersionFeature;
+import org.elasticsearch.logging.internal.spi.LoggerFactory;
 import org.elasticsearch.plugins.AnalysisPlugin;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.plugins.scanners.StablePluginsRegistry;
@@ -575,6 +576,23 @@ public void removeHeaderWarningAppender() {
         }
     }
 
+    private static org.elasticsearch.logging.Level capturedLogLevel = null;
+
+    // just capture the expected level once before the suite starts
+    @BeforeClass
+    public static void captureLoggingLevel() {
+        capturedLogLevel = LoggerFactory.provider().getRootLevel();
+    }
+
+    @AfterClass
+    public static void restoreLoggingLevel() {
+        if (capturedLogLevel != null) {
+            // log level might not have been captured if suite was skipped
+            LoggerFactory.provider().setRootLevel(capturedLogLevel);
+            capturedLogLevel = null;
+        }
+    }
+
     @Before
     public final void before() {
         LeakTracker.setContextHint(getTestName());
diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/LuceneSourceOperator.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/LuceneSourceOperator.java
@@ -232,12 +232,13 @@ private IntVector buildDocsVector(int upToPositions) {
         if (docs.getPositionCount() == upToPositions) {
             return docs;
         }
-        try (var slice = blockFactory.newIntVectorFixedBuilder(upToPositions)) {
-            for (int i = 0; i < upToPositions; i++) {
-                slice.appendInt(docs.getInt(i));
+        try (docs) {
+            try (var slice = blockFactory.newIntVectorFixedBuilder(upToPositions)) {
+                for (int i = 0; i < upToPositions; i++) {
+                    slice.appendInt(docs.getInt(i));
+                }
+                return slice.build();
             }
-            docs.close();
-            return slice.build();
         }
     }
 
@@ -247,12 +248,13 @@ private DoubleVector buildScoresVector(int upToPositions) {
         if (scores.getPositionCount() == upToPositions) {
             return scores;
         }
-        try (var slice = blockFactory.newDoubleVectorBuilder(upToPositions)) {
-            for (int i = 0; i < upToPositions; i++) {
-                slice.appendDouble(scores.getDouble(i));
+        try (scores) {
+            try (var slice = blockFactory.newDoubleVectorBuilder(upToPositions)) {
+                for (int i = 0; i < upToPositions; i++) {
+                    slice.appendDouble(scores.getDouble(i));
+                }
+                return slice.build();
             }
-            scores.close();
-            return slice.build();
         }
     }
 
diff --git a/x-pack/plugin/security/src/main/java/module-info.java b/x-pack/plugin/security/src/main/java/module-info.java

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@`
`11`	`11`	`module org.elasticsearch.cli {`
`12`	`12`	`requires jopt.simple;`
`13`	`13`	`requires org.elasticsearch.base;`
	`14`	`+ requires java.logging;`
	`15`	`+ requires org.elasticsearch.logging;`
`14`	`16`
`15`	`17`	`exports org.elasticsearch.cli;`
`16`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,8 +91,8 @@ static FileData ofRelativePath(Path relativePath, BaseDir baseDir, Mode mode) {`
`91`	`91`	`return new RelativePathFileData(relativePath, baseDir, mode, null, false);`
`92`	`92`	`}`
`93`	`93`
`94`		`- static FileData ofPathSetting(String setting, BaseDir baseDir, Mode mode, boolean ignoreUrl) {`
`95`		`- return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, null, false);`
	`94`	`+ static FileData ofPathSetting(String setting, BaseDir baseDir, Mode mode) {`
	`95`	`+ return new PathSettingFileData(setting, baseDir, mode, null, false);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/**`
`@@ -220,30 +220,29 @@ public FileData withPlatform(Platform platform) {`
`220`	`220`	`}`
`221`	`221`	`}`
`222`	`222`
`223`		`- private record PathSettingFileData(String setting, BaseDir baseDir, Mode mode, boolean ignoreUrl, Platform platform, boolean exclusive)`
	`223`	`+ private record PathSettingFileData(String setting, BaseDir baseDir, Mode mode, Platform platform, boolean exclusive)`
`224`	`224`	`implements`
`225`	`225`	`RelativeFileData {`
`226`	`226`
`227`	`227`	`@Override`
`228`	`228`	`public PathSettingFileData withExclusive(boolean exclusive) {`
`229`		`- return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, platform, exclusive);`
	`229`	`+ return new PathSettingFileData(setting, baseDir, mode, platform, exclusive);`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`@Override`
`233`	`233`	`public Stream<Path> resolveRelativePaths(PathLookup pathLookup) {`
`234`		`- Stream<String> result = pathLookup.settingResolver().apply(setting);`
`235`		`- if (ignoreUrl) {`
`236`		`- result = result.filter(s -> s.toLowerCase(Locale.ROOT).startsWith("https://") == false);`
`237`		`- }`
`238`		`- return result.map(pathLookup.configDir()::resolve);`
	`234`	`+ Stream<String> result = pathLookup.settingResolver()`
	`235`	`+ .apply(setting)`
	`236`	`+ .filter(s -> s.toLowerCase(Locale.ROOT).startsWith("https://") == false);`
	`237`	`+ return result.map(Path::of);`
`239`	`238`	`}`
`240`	`239`
`241`	`240`	`@Override`
`242`	`241`	`public FileData withPlatform(Platform platform) {`
`243`	`242`	`if (platform == platform()) {`
`244`	`243`	`return this;`
`245`	`244`	`}`
`246`		`- return new PathSettingFileData(setting, baseDir, mode, ignoreUrl, platform, exclusive);`
	`245`	`+ return new PathSettingFileData(setting, baseDir, mode, platform, exclusive);`
`247`	`246`	`}`
`248`	`247`	`}`
`249`	`248`
`@@ -331,8 +330,6 @@ public static FilesEntitlement build(List<Object> paths) {`
`331`	`330`	`String settingBaseDirAsString = checkString.apply(file, "basedir_if_relative");`
`332`	`331`	`String modeAsString = checkString.apply(file, "mode");`
`333`	`332`	`String platformAsString = checkString.apply(file, "platform");`
`334`		`- Boolean ignoreUrlAsStringBoolean = checkBoolean.apply(file, "ignore_url");`
`335`		`- boolean ignoreUrlAsString = ignoreUrlAsStringBoolean != null && ignoreUrlAsStringBoolean;`
`336`	`333`	`Boolean exclusiveBoolean = checkBoolean.apply(file, "exclusive");`
`337`	`334`	`boolean exclusive = exclusiveBoolean != null && exclusiveBoolean;`
`338`	`335`
`@@ -359,9 +356,6 @@ public static FilesEntitlement build(List<Object> paths) {`
`359`	`356`	`throw new PolicyValidationException("'relative_to' may only be used with 'relative_path'");`
`360`	`357`	`}`
`361`	`358`
`362`		`- if (ignoreUrlAsStringBoolean != null && pathSetting == null) {`
`363`		`- throw new PolicyValidationException("'ignore_url' may only be used with 'path_setting'");`
`364`		`- }`
`365`	`359`	`if (settingBaseDirAsString != null && pathSetting == null) {`
`366`	`360`	`throw new PolicyValidationException("'basedir_if_relative' may only be used with 'path_setting'");`
`367`	`361`	`}`
`@@ -388,7 +382,7 @@ public static FilesEntitlement build(List<Object> paths) {`
`388`	`382`	`throw new PolicyValidationException("files entitlement with a 'path_setting' must specify 'basedir_if_relative'");`
`389`	`383`	`}`
`390`	`384`	`BaseDir baseDir = parseBaseDir(settingBaseDirAsString);`
`391`		`- fileData = FileData.ofPathSetting(pathSetting, baseDir, mode, ignoreUrlAsString);`
	`385`	`+ fileData = FileData.ofPathSetting(pathSetting, baseDir, mode);`
`392`	`386`	`} else {`
`393`	`387`	`throw new AssertionError("File entry validation error");`
`394`	`388`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@`
`9`	`9`
`10`	`10`	`module org.elasticsearch.logging {`
`11`	`11`	`exports org.elasticsearch.logging;`
`12`		`- exports org.elasticsearch.logging.internal.spi to org.elasticsearch.server;`
	`12`	`+ exports org.elasticsearch.logging.internal.spi to org.elasticsearch.server, org.elasticsearch.cli;`
`13`	`13`	`}`