From 290e82ac0a80e91d6a5cd906bb80f07bc18c8dd3 Mon Sep 17 00:00:00 2001 From: Ry Biesemeyer Date: Mon, 21 Jul 2025 20:52:33 +0000 Subject: [PATCH] spike refactor of logstashbridge stable API - transitions terminology from wrap/unwrap to toInternal/fromInternal - adds abstract base class for ProcessorBridge, since we are expecting external implementations, which includes an internal-shaped proxy to the external definition. - adds copious commentary for the classes that were previously shipped --- .../logstashbridge/StableBridgeAPI.java | 42 +++-- .../logstashbridge/common/SettingsBridge.java | 24 ++- .../logstashbridge/core/IOUtilsBridge.java | 3 + .../logstashbridge/env/EnvironmentBridge.java | 13 +- .../ingest/ConfigurationUtilsBridge.java | 5 +- .../ingest/IngestDocumentBridge.java | 36 ++-- .../logstashbridge/ingest/PipelineBridge.java | 21 ++- .../ingest/PipelineConfigurationBridge.java | 17 +- .../ingest/ProcessorBridge.java | 166 +++++++++++------- .../plugins/IngestCommonPluginBridge.java | 5 +- .../plugins/IngestPluginBridge.java | 23 ++- .../plugins/IngestUserAgentPluginBridge.java | 5 +- .../plugins/RedactPluginBridge.java | 7 +- .../logstashbridge/script/MetadataBridge.java | 27 +-- .../script/ScriptServiceBridge.java | 11 +- .../script/TemplateScriptBridge.java | 15 +- .../threadpool/ThreadPoolBridge.java | 13 +- 17 files changed, 265 insertions(+), 168 deletions(-) diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/StableBridgeAPI.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/StableBridgeAPI.java index d4cd946d74799..c965fd8f46c35 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/StableBridgeAPI.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/StableBridgeAPI.java @@ -19,43 +19,51 @@ * upon by the "Elastic Integration Filter Plugin" for Logstash and their external shapes must not change * without coordination with the maintainers of that project. * - * @param the actual type of the Elasticsearch API being mirrored + * @param the actual type of the Elasticsearch API being mirrored */ -public interface StableBridgeAPI { - T unwrap(); +public interface StableBridgeAPI { + INTERNAL toInternal(); - static T unwrapNullable(final StableBridgeAPI nullableStableBridgeAPI) { + static T toInternalNullable(final StableBridgeAPI nullableStableBridgeAPI) { if (Objects.isNull(nullableStableBridgeAPI)) { return null; } - return nullableStableBridgeAPI.unwrap(); + return nullableStableBridgeAPI.toInternal(); } - static Map unwrap(final Map> bridgeMap) { - return bridgeMap.entrySet().stream().collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, e -> e.getValue().unwrap())); + static Map toInternal(final Map> bridgeMap) { + return bridgeMap.entrySet().stream().collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, e -> e.getValue().toInternal())); } - static > Map wrap(final Map rawMap, final Function wrapFunction) { - return rawMap.entrySet().stream().collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, e -> wrapFunction.apply(e.getValue()))); + static > Map fromInternal(final Map rawMap, final Function externalizor) { + return rawMap.entrySet() + .stream() + .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, e -> externalizor.apply(e.getValue()))); } - static > B wrap(final T delegate, final Function wrapFunction) { + static > B fromInternal(final T delegate, final Function externalizor) { if (Objects.isNull(delegate)) { return null; } - return wrapFunction.apply(delegate); + return externalizor.apply(delegate); } - abstract class Proxy implements StableBridgeAPI { - protected final T delegate; + /** + * An {@code ProxyInternal} is an implementation of {@code StableBridgeAPI} that + * proxies calls to a delegate that is an actual {@code INTERNAL}. + * + * @param + */ + abstract class ProxyInternal implements StableBridgeAPI { + protected final INTERNAL internalDelegate; - protected Proxy(final T delegate) { - this.delegate = delegate; + protected ProxyInternal(final INTERNAL internalDelegate) { + this.internalDelegate = internalDelegate; } @Override - public T unwrap() { - return delegate; + public INTERNAL toInternal() { + return internalDelegate; } } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/common/SettingsBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/common/SettingsBridge.java index 304f4c902bcef..4139191995dc8 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/common/SettingsBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/common/SettingsBridge.java @@ -11,14 +11,17 @@ import org.elasticsearch.common.settings.Settings; import org.elasticsearch.logstashbridge.StableBridgeAPI; -public class SettingsBridge extends StableBridgeAPI.Proxy { +/** + * An external bridge for {@link Settings} + */ +public class SettingsBridge extends StableBridgeAPI.ProxyInternal { - public static SettingsBridge wrap(final Settings delegate) { + public static SettingsBridge fromInternal(final Settings delegate) { return new SettingsBridge(delegate); } public static Builder builder() { - return Builder.wrap(Settings.builder()); + return Builder.fromInternal(Settings.builder()); } public SettingsBridge(final Settings delegate) { @@ -26,12 +29,15 @@ public SettingsBridge(final Settings delegate) { } @Override - public Settings unwrap() { - return this.delegate; + public Settings toInternal() { + return this.internalDelegate; } - public static class Builder extends StableBridgeAPI.Proxy { - static Builder wrap(final Settings.Builder delegate) { + /** + * An external bridge for {@link Settings.Builder} that proxies calls to a real {@link Settings.Builder} + */ + public static class Builder extends StableBridgeAPI.ProxyInternal { + static Builder fromInternal(final Settings.Builder delegate) { return new Builder(delegate); } @@ -40,12 +46,12 @@ private Builder(final Settings.Builder delegate) { } public Builder put(final String key, final String value) { - this.delegate.put(key, value); + this.internalDelegate.put(key, value); return this; } public SettingsBridge build() { - return new SettingsBridge(this.delegate.build()); + return new SettingsBridge(this.internalDelegate.build()); } } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/core/IOUtilsBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/core/IOUtilsBridge.java index 1e300bee6881f..e73331c62c71a 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/core/IOUtilsBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/core/IOUtilsBridge.java @@ -12,6 +12,9 @@ import java.io.Closeable; +/** + * An external bridge for {@link IOUtils} + */ public class IOUtilsBridge { public static void closeWhileHandlingException(final Iterable objects) { IOUtils.closeWhileHandlingException(objects); diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/env/EnvironmentBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/env/EnvironmentBridge.java index 236b05dd034e9..086d2ae5a3dc4 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/env/EnvironmentBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/env/EnvironmentBridge.java @@ -14,13 +14,16 @@ import java.nio.file.Path; -public class EnvironmentBridge extends StableBridgeAPI.Proxy { - public static EnvironmentBridge wrap(final Environment delegate) { +/** + * An external bridge for {@link Environment} + */ +public class EnvironmentBridge extends StableBridgeAPI.ProxyInternal { + public static EnvironmentBridge fromInternal(final Environment delegate) { return new EnvironmentBridge(delegate); } public EnvironmentBridge(final SettingsBridge settingsBridge, final Path configPath) { - this(new Environment(settingsBridge.unwrap(), configPath)); + this(new Environment(settingsBridge.toInternal(), configPath)); } private EnvironmentBridge(final Environment delegate) { @@ -28,7 +31,7 @@ private EnvironmentBridge(final Environment delegate) { } @Override - public Environment unwrap() { - return this.delegate; + public Environment toInternal() { + return this.internalDelegate; } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ConfigurationUtilsBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ConfigurationUtilsBridge.java index 760bd12a5a9da..07178ca65a460 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ConfigurationUtilsBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ConfigurationUtilsBridge.java @@ -14,6 +14,9 @@ import java.util.Map; +/** + * An external bridge for {@link ConfigurationUtils} + */ public class ConfigurationUtilsBridge { public static TemplateScriptBridge.Factory compileTemplate( final String processorType, @@ -23,7 +26,7 @@ public static TemplateScriptBridge.Factory compileTemplate( final ScriptServiceBridge scriptServiceBridge ) { return new TemplateScriptBridge.Factory( - ConfigurationUtils.compileTemplate(processorType, processorTag, propertyName, propertyValue, scriptServiceBridge.unwrap()) + ConfigurationUtils.compileTemplate(processorType, processorTag, propertyName, propertyValue, scriptServiceBridge.toInternal()) ); } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/IngestDocumentBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/IngestDocumentBridge.java index 239058f9333e2..8a1255c816ac1 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/IngestDocumentBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/IngestDocumentBridge.java @@ -18,7 +18,10 @@ import java.util.Set; import java.util.function.BiConsumer; -public class IngestDocumentBridge extends StableBridgeAPI.Proxy { +/** + * An external bridge for {@link IngestDocument} that proxies calls through a real {@link IngestDocument} + */ +public class IngestDocumentBridge extends StableBridgeAPI.ProxyInternal { public static final class Constants { public static final String METADATA_VERSION_FIELD_NAME = IngestDocument.Metadata.VERSION.getFieldName(); @@ -26,7 +29,7 @@ public static final class Constants { private Constants() {} } - public static IngestDocumentBridge wrap(final IngestDocument ingestDocument) { + public static IngestDocumentBridge fromInternalNullable(final IngestDocument ingestDocument) { if (ingestDocument == null) { return null; } @@ -42,54 +45,57 @@ private IngestDocumentBridge(IngestDocument inner) { } public MetadataBridge getMetadata() { - return new MetadataBridge(delegate.getMetadata()); + return new MetadataBridge(internalDelegate.getMetadata()); } public Map getSource() { - return delegate.getSource(); + return internalDelegate.getSource(); } public boolean updateIndexHistory(final String index) { - return delegate.updateIndexHistory(index); + return internalDelegate.updateIndexHistory(index); } public Set getIndexHistory() { - return Set.copyOf(delegate.getIndexHistory()); + return Set.copyOf(internalDelegate.getIndexHistory()); } public boolean isReroute() { - return LogstashInternalBridge.isReroute(delegate); + return LogstashInternalBridge.isReroute(internalDelegate); } public void resetReroute() { - LogstashInternalBridge.resetReroute(delegate); + LogstashInternalBridge.resetReroute(internalDelegate); } public Map getIngestMetadata() { - return delegate.getIngestMetadata(); + return internalDelegate.getIngestMetadata(); } public T getFieldValue(final String fieldName, final Class type) { - return delegate.getFieldValue(fieldName, type); + return internalDelegate.getFieldValue(fieldName, type); } public T getFieldValue(final String fieldName, final Class type, final boolean ignoreMissing) { - return delegate.getFieldValue(fieldName, type, ignoreMissing); + return internalDelegate.getFieldValue(fieldName, type, ignoreMissing); } public String renderTemplate(final TemplateScriptBridge.Factory templateScriptFactory) { - return delegate.renderTemplate(templateScriptFactory.unwrap()); + return internalDelegate.renderTemplate(templateScriptFactory.toInternal()); } public void setFieldValue(final String path, final Object value) { - delegate.setFieldValue(path, value); + internalDelegate.setFieldValue(path, value); } public void removeField(final String path) { - delegate.removeField(path); + internalDelegate.removeField(path); } public void executePipeline(final PipelineBridge pipelineBridge, final BiConsumer handler) { - this.delegate.executePipeline(pipelineBridge.unwrap(), (unwrapped, e) -> handler.accept(IngestDocumentBridge.wrap(unwrapped), e)); + this.internalDelegate.executePipeline(pipelineBridge.toInternal(), + (ingestDocument, e) -> { + handler.accept(IngestDocumentBridge.fromInternalNullable(ingestDocument), e); + }); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineBridge.java index 6a5d437f75d81..19ee577ef0874 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineBridge.java @@ -16,8 +16,11 @@ import java.util.Map; import java.util.function.BiConsumer; -public class PipelineBridge extends StableBridgeAPI.Proxy { - public static PipelineBridge wrap(final Pipeline pipeline) { +/** + * An external bridge for {@link Pipeline} + */ +public class PipelineBridge extends StableBridgeAPI.ProxyInternal { + public static PipelineBridge fromInternal(final Pipeline pipeline) { return new PipelineBridge(pipeline); } @@ -28,12 +31,12 @@ public static PipelineBridge create( Map processorFactories, ScriptServiceBridge scriptServiceBridge ) throws Exception { - return wrap( + return fromInternal( Pipeline.create( id, config, - StableBridgeAPI.unwrap(processorFactories), - StableBridgeAPI.unwrapNullable(scriptServiceBridge), + StableBridgeAPI.toInternal(processorFactories), + StableBridgeAPI.toInternalNullable(scriptServiceBridge), null ) ); @@ -44,13 +47,13 @@ public PipelineBridge(final Pipeline delegate) { } public String getId() { - return delegate.getId(); + return internalDelegate.getId(); } public void execute(final IngestDocumentBridge ingestDocumentBridge, final BiConsumer handler) { - this.delegate.execute( - StableBridgeAPI.unwrapNullable(ingestDocumentBridge), - (unwrapped, e) -> handler.accept(IngestDocumentBridge.wrap(unwrapped), e) + this.internalDelegate.execute( + StableBridgeAPI.toInternalNullable(ingestDocumentBridge), + (ingestDocument, e) -> handler.accept(IngestDocumentBridge.fromInternalNullable(ingestDocument), e) ); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineConfigurationBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineConfigurationBridge.java index cb90d10665659..22a039702f82c 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineConfigurationBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/PipelineConfigurationBridge.java @@ -15,7 +15,10 @@ import java.util.Map; -public class PipelineConfigurationBridge extends StableBridgeAPI.Proxy { +/** + * An external bridge for {@link PipelineConfiguration} + */ +public class PipelineConfigurationBridge extends StableBridgeAPI.ProxyInternal { public PipelineConfigurationBridge(final PipelineConfiguration delegate) { super(delegate); } @@ -25,25 +28,25 @@ public PipelineConfigurationBridge(final String pipelineId, final String jsonEnc } public String getId() { - return delegate.getId(); + return internalDelegate.getId(); } public Map getConfig() { - return delegate.getConfig(); + return internalDelegate.getConfig(); } public Map getConfig(final boolean unmodifiable) { - return delegate.getConfig(unmodifiable); + return internalDelegate.getConfig(unmodifiable); } @Override public int hashCode() { - return delegate.hashCode(); + return internalDelegate.hashCode(); } @Override public String toString() { - return delegate.toString(); + return internalDelegate.toString(); } @Override @@ -51,7 +54,7 @@ public boolean equals(final Object obj) { if (this == obj) { return true; } else if (obj instanceof PipelineConfigurationBridge other) { - return delegate.equals(other.delegate); + return internalDelegate.equals(other.internalDelegate); } else { return false; } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ProcessorBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ProcessorBridge.java index b4b3766ecf183..3096b8e952b5f 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ProcessorBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/ingest/ProcessorBridge.java @@ -22,8 +22,14 @@ import java.util.Map; import java.util.function.BiConsumer; +/** + * An external bridge for {@link Processor} + */ public interface ProcessorBridge extends StableBridgeAPI { + /** + * An external bridge for processor-related constants + */ final class Constants { private Constants() {} @@ -72,86 +78,104 @@ private Constants() {} void execute(IngestDocumentBridge ingestDocumentBridge, BiConsumer handler); - static ProcessorBridge wrap(final Processor delegate) { - if (delegate instanceof InverseWrapped inverseWrapped) { - return inverseWrapped.delegate; + static ProcessorBridge fromInternal(final Processor internalProcessor) { + if (internalProcessor instanceof AbstractExternal.ProxyExternal externalProxy) { + return externalProxy.getProcessorBridge(); } - return new Wrapped(delegate); + return new ProxyInternal(internalProcessor); } - class Wrapped extends StableBridgeAPI.Proxy implements ProcessorBridge { - public Wrapped(final Processor delegate) { - super(delegate); + /** + * The {@code ProcessorBridge.AbstractExternal} is an abstract base class for implementing + * the {@link ProcessorBridge} externally to the Elasticsearch code-base. It takes care of + * the details of maintaining a singular internal-form implementation of {@link Processor} + * that proxies calls through the external implementation. + */ + abstract class AbstractExternal implements ProcessorBridge { + private ProxyExternal internalProcessor; + + public Processor toInternal() { + if (internalProcessor == null) { + internalProcessor = new ProxyExternal(); + } + return internalProcessor; } - @Override - public String getType() { - return unwrap().getType(); - } + private class ProxyExternal implements Processor { - @Override - public String getTag() { - return unwrap().getTag(); - } + @Override + public String getType() { + return AbstractExternal.this.getType(); + } - @Override - public String getDescription() { - return unwrap().getDescription(); - } + @Override + public String getTag() { + return AbstractExternal.this.getTag(); + } - @Override - public boolean isAsync() { - return unwrap().isAsync(); - } + @Override + public String getDescription() { + return AbstractExternal.this.getDescription(); + } - @Override - public void execute(final IngestDocumentBridge ingestDocumentBridge, final BiConsumer handler) { - delegate.execute( - StableBridgeAPI.unwrapNullable(ingestDocumentBridge), - (id, e) -> handler.accept(IngestDocumentBridge.wrap(id), e) - ); - } - } + @Override + public void execute(IngestDocument ingestDocument, BiConsumer handler) { + AbstractExternal.this.execute(IngestDocumentBridge.fromInternalNullable(ingestDocument), + (idb, e) -> handler.accept(idb.toInternal(), e)); + } - @Override - default Processor unwrap() { - return new InverseWrapped(this); - } + @Override + public boolean isAsync() { + return AbstractExternal.this.isAsync(); + } - class InverseWrapped implements Processor { - private final ProcessorBridge delegate; + private AbstractExternal getProcessorBridge() { + return AbstractExternal.this; + } + } + } - public InverseWrapped(final ProcessorBridge delegate) { - this.delegate = delegate; + /** + * An implementation of {@link ProcessorBridge} that proxies to an internal {@link Processor} + */ + class ProxyInternal extends StableBridgeAPI.ProxyInternal implements ProcessorBridge { + public ProxyInternal(final Processor delegate) { + super(delegate); } @Override public String getType() { - return delegate.getType(); + return toInternal().getType(); } @Override public String getTag() { - return delegate.getTag(); + return toInternal().getTag(); } @Override public String getDescription() { - return delegate.getDescription(); + return toInternal().getDescription(); } @Override - public void execute(IngestDocument ingestDocument, BiConsumer handler) { - this.delegate.execute(IngestDocumentBridge.wrap(ingestDocument), (idb, e) -> handler.accept(idb.unwrap(), e)); + public boolean isAsync() { + return toInternal().isAsync(); } @Override - public boolean isAsync() { - return delegate.isAsync(); + public void execute(final IngestDocumentBridge ingestDocumentBridge, final BiConsumer handler) { + internalDelegate.execute( + StableBridgeAPI.toInternalNullable(ingestDocumentBridge), + (id, e) -> handler.accept(IngestDocumentBridge.fromInternalNullable(id), e) + ); } } - class Parameters extends StableBridgeAPI.Proxy { + /** + * An external bridge for {@link Processor.Parameters} + */ + class Parameters extends StableBridgeAPI.ProxyInternal { public Parameters( final EnvironmentBridge environmentBridge, @@ -160,17 +184,17 @@ public Parameters( ) { this( new Processor.Parameters( - environmentBridge.unwrap(), - scriptServiceBridge.unwrap(), + environmentBridge.toInternal(), + scriptServiceBridge.toInternal(), null, - threadPoolBridge.unwrap().getThreadContext(), - threadPoolBridge.unwrap()::relativeTimeInMillis, - (delay, command) -> threadPoolBridge.unwrap() - .schedule(command, TimeValue.timeValueMillis(delay), threadPoolBridge.unwrap().generic()), + threadPoolBridge.toInternal().getThreadContext(), + threadPoolBridge.toInternal()::relativeTimeInMillis, + (delay, command) -> threadPoolBridge.toInternal() + .schedule(command, TimeValue.timeValueMillis(delay), threadPoolBridge.toInternal().generic()), null, null, - threadPoolBridge.unwrap().generic()::execute, - IngestService.createGrokThreadWatchdog(environmentBridge.unwrap(), threadPoolBridge.unwrap()) + threadPoolBridge.toInternal().generic()::execute, + IngestService.createGrokThreadWatchdog(environmentBridge.toInternal(), threadPoolBridge.toInternal()) ) ); } @@ -180,11 +204,14 @@ private Parameters(final Processor.Parameters delegate) { } @Override - public Processor.Parameters unwrap() { - return this.delegate; + public Processor.Parameters toInternal() { + return this.internalDelegate; } } + /** + * An external bridge for {@link Processor.Factory} + */ interface Factory extends StableBridgeAPI { ProcessorBridge create( Map registry, @@ -193,23 +220,26 @@ ProcessorBridge create( Map config ) throws Exception; - static Factory wrap(final Processor.Factory delegate) { - return new Wrapped(delegate); + static Factory fromInternal(final Processor.Factory delegate) { + return new ProxyInternal(delegate); } @Override - default Processor.Factory unwrap() { + default Processor.Factory toInternal() { final Factory stableAPIFactory = this; return (registry, tag, description, config, projectId) -> stableAPIFactory.create( - StableBridgeAPI.wrap(registry, Factory::wrap), + StableBridgeAPI.fromInternal(registry, Factory::fromInternal), tag, description, config - ).unwrap(); + ).toInternal(); } - class Wrapped extends StableBridgeAPI.Proxy implements Factory { - private Wrapped(final Processor.Factory delegate) { + /** + * An implementation of {@link ProcessorBridge.Factory} that proxies to an internal {@link Processor.Factory} + */ + class ProxyInternal extends StableBridgeAPI.ProxyInternal implements Factory { + private ProxyInternal(final Processor.Factory delegate) { super(delegate); } @@ -221,14 +251,14 @@ public ProcessorBridge create( final String description, final Map config ) throws Exception { - return ProcessorBridge.wrap( - this.delegate.create(StableBridgeAPI.unwrap(registry), processorTag, description, config, ProjectId.DEFAULT) + return ProcessorBridge.fromInternal( + this.internalDelegate.create(StableBridgeAPI.toInternal(registry), processorTag, description, config, ProjectId.DEFAULT) ); } @Override - public Processor.Factory unwrap() { - return this.delegate; + public Processor.Factory toInternal() { + return this.internalDelegate; } } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestCommonPluginBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestCommonPluginBridge.java index 436e1fe757a57..065977d834fb0 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestCommonPluginBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestCommonPluginBridge.java @@ -14,6 +14,9 @@ import java.util.Map; +/** + * An external bridge for {@link IngestCommonPlugin} + */ public class IngestCommonPluginBridge implements IngestPluginBridge { private final IngestCommonPlugin delegate; @@ -24,6 +27,6 @@ public IngestCommonPluginBridge() { @Override public Map getProcessors(final ProcessorBridge.Parameters parameters) { - return StableBridgeAPI.wrap(this.delegate.getProcessors(parameters.unwrap()), ProcessorBridge.Factory::wrap); + return StableBridgeAPI.fromInternal(this.delegate.getProcessors(parameters.toInternal()), ProcessorBridge.Factory::fromInternal); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestPluginBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestPluginBridge.java index 49a719e576c41..916244949f4e6 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestPluginBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestPluginBridge.java @@ -16,31 +16,38 @@ import java.io.IOException; import java.util.Map; +/** + * An external bridge for {@link IngestPlugin} + */ public interface IngestPluginBridge { Map getProcessors(ProcessorBridge.Parameters parameters); - static Wrapped wrap(final IngestPlugin delegate) { - return new Wrapped(delegate); + static ProxyInternal fromInternal(final IngestPlugin delegate) { + return new ProxyInternal(delegate); } - class Wrapped extends StableBridgeAPI.Proxy implements IngestPluginBridge, Closeable { + /** + * An implementation of {@link IngestPluginBridge} that proxies calls to an internal {@link IngestPlugin} + */ + class ProxyInternal extends StableBridgeAPI.ProxyInternal implements IngestPluginBridge, Closeable { - private Wrapped(final IngestPlugin delegate) { + private ProxyInternal(final IngestPlugin delegate) { super(delegate); } public Map getProcessors(final ProcessorBridge.Parameters parameters) { - return StableBridgeAPI.wrap(this.delegate.getProcessors(parameters.unwrap()), ProcessorBridge.Factory::wrap); + return StableBridgeAPI.fromInternal(this.internalDelegate.getProcessors(parameters.toInternal()), + ProcessorBridge.Factory::fromInternal); } @Override - public IngestPlugin unwrap() { - return this.delegate; + public IngestPlugin toInternal() { + return this.internalDelegate; } @Override public void close() throws IOException { - if (this.delegate instanceof Closeable closeableDelegate) { + if (this.internalDelegate instanceof Closeable closeableDelegate) { closeableDelegate.close(); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestUserAgentPluginBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestUserAgentPluginBridge.java index 5e60d18575932..4c936e7143571 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestUserAgentPluginBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/IngestUserAgentPluginBridge.java @@ -14,6 +14,9 @@ import java.util.Map; +/** + * An external bridge for {@link IngestUserAgentPlugin} + */ public class IngestUserAgentPluginBridge implements IngestPluginBridge { private final IngestUserAgentPlugin delegate; @@ -23,6 +26,6 @@ public IngestUserAgentPluginBridge() { } public Map getProcessors(final ProcessorBridge.Parameters parameters) { - return StableBridgeAPI.wrap(this.delegate.getProcessors(parameters.unwrap()), ProcessorBridge.Factory::wrap); + return StableBridgeAPI.fromInternal(this.delegate.getProcessors(parameters.toInternal()), ProcessorBridge.Factory::fromInternal); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/RedactPluginBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/RedactPluginBridge.java index 4760a7df9eee4..4e59e5531838f 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/RedactPluginBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/plugins/RedactPluginBridge.java @@ -14,15 +14,18 @@ import java.util.Map; +/** + * An external bridge for {@link org.elasticsearch.xpack.redact.RedactPlugin} + */ public class RedactPluginBridge implements IngestPluginBridge { @Override public Map getProcessors(ProcessorBridge.Parameters parameters) { // Provide a TRIAL license state to the redact processor - final XPackLicenseState trialLicenseState = new XPackLicenseState(parameters.unwrap().relativeTimeSupplier); + final XPackLicenseState trialLicenseState = new XPackLicenseState(parameters.toInternal().relativeTimeSupplier); return Map.of( RedactProcessor.TYPE, - ProcessorBridge.Factory.wrap(new RedactProcessor.Factory(trialLicenseState, parameters.unwrap().matcherWatchdog)) + ProcessorBridge.Factory.fromInternal(new RedactProcessor.Factory(trialLicenseState, parameters.toInternal().matcherWatchdog)) ); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/MetadataBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/MetadataBridge.java index e4dbb3bc8b4ee..1a9f93d65af3c 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/MetadataBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/MetadataBridge.java @@ -13,52 +13,55 @@ import java.time.ZonedDateTime; -public class MetadataBridge extends StableBridgeAPI.Proxy { +/** + * An external bridge for {@link Metadata} + */ +public class MetadataBridge extends StableBridgeAPI.ProxyInternal { public MetadataBridge(final Metadata delegate) { super(delegate); } public String getIndex() { - return delegate.getIndex(); + return internalDelegate.getIndex(); } public void setIndex(final String index) { - delegate.setIndex(index); + internalDelegate.setIndex(index); } public String getId() { - return delegate.getId(); + return internalDelegate.getId(); } public void setId(final String id) { - delegate.setId(id); + internalDelegate.setId(id); } public long getVersion() { - return delegate.getVersion(); + return internalDelegate.getVersion(); } public void setVersion(final long version) { - delegate.setVersion(version); + internalDelegate.setVersion(version); } public String getVersionType() { - return delegate.getVersionType(); + return internalDelegate.getVersionType(); } public void setVersionType(final String versionType) { - delegate.setVersionType(versionType); + internalDelegate.setVersionType(versionType); } public String getRouting() { - return delegate.getRouting(); + return internalDelegate.getRouting(); } public void setRouting(final String routing) { - delegate.setRouting(routing); + internalDelegate.setRouting(routing); } public ZonedDateTime getNow() { - return delegate.getNow(); + return internalDelegate.getNow(); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/ScriptServiceBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/ScriptServiceBridge.java index c674afd12c5d5..d13731fb67bed 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/ScriptServiceBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/ScriptServiceBridge.java @@ -36,13 +36,16 @@ import java.util.Set; import java.util.function.LongSupplier; -public class ScriptServiceBridge extends StableBridgeAPI.Proxy implements Closeable { - public ScriptServiceBridge wrap(final ScriptService delegate) { +/** + * An external bridge for {@link ScriptService} + */ +public class ScriptServiceBridge extends StableBridgeAPI.ProxyInternal implements Closeable { + public ScriptServiceBridge fromInternal(final ScriptService delegate) { return new ScriptServiceBridge(delegate); } public ScriptServiceBridge(final SettingsBridge settingsBridge, final LongSupplier timeProvider) throws IOException { - super(getScriptService(settingsBridge.unwrap(), timeProvider)); + super(getScriptService(settingsBridge.toInternal(), timeProvider)); } public ScriptServiceBridge(ScriptService delegate) { @@ -103,6 +106,6 @@ public List loadExtensions(Class extensionPointType) { @Override public void close() throws IOException { - this.delegate.close(); + this.internalDelegate.close(); } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/TemplateScriptBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/TemplateScriptBridge.java index a184a51676048..58c38a8f224a3 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/TemplateScriptBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/script/TemplateScriptBridge.java @@ -11,9 +11,16 @@ import org.elasticsearch.logstashbridge.StableBridgeAPI; import org.elasticsearch.script.TemplateScript; +/** + * An external bridge for {@link TemplateScript} + */ public class TemplateScriptBridge { - public static class Factory extends StableBridgeAPI.Proxy { - public static Factory wrap(final TemplateScript.Factory delegate) { + + /** + * An external bridge for {@link TemplateScript.Factory} + */ + public static class Factory extends StableBridgeAPI.ProxyInternal { + public static Factory fromInternal(final TemplateScript.Factory delegate) { return new Factory(delegate); } @@ -22,8 +29,8 @@ public Factory(final TemplateScript.Factory delegate) { } @Override - public TemplateScript.Factory unwrap() { - return this.delegate; + public TemplateScript.Factory toInternal() { + return this.internalDelegate; } } } diff --git a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/threadpool/ThreadPoolBridge.java b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/threadpool/ThreadPoolBridge.java index d16cca1dd865a..dee0381d30c22 100644 --- a/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/threadpool/ThreadPoolBridge.java +++ b/libs/logstash-bridge/src/main/java/org/elasticsearch/logstashbridge/threadpool/ThreadPoolBridge.java @@ -16,10 +16,13 @@ import java.util.concurrent.TimeUnit; -public class ThreadPoolBridge extends StableBridgeAPI.Proxy { +/** + * An external bridge for {@link ThreadPool} + */ +public class ThreadPoolBridge extends StableBridgeAPI.ProxyInternal { public ThreadPoolBridge(final SettingsBridge settingsBridge) { - this(new ThreadPool(settingsBridge.unwrap(), MeterRegistry.NOOP, new DefaultBuiltInExecutorBuilders())); + this(new ThreadPool(settingsBridge.toInternal(), MeterRegistry.NOOP, new DefaultBuiltInExecutorBuilders())); } public ThreadPoolBridge(final ThreadPool delegate) { @@ -27,14 +30,14 @@ public ThreadPoolBridge(final ThreadPool delegate) { } public static boolean terminate(final ThreadPoolBridge pool, final long timeout, final TimeUnit timeUnit) { - return ThreadPool.terminate(pool.unwrap(), timeout, timeUnit); + return ThreadPool.terminate(pool.toInternal(), timeout, timeUnit); } public long relativeTimeInMillis() { - return delegate.relativeTimeInMillis(); + return internalDelegate.relativeTimeInMillis(); } public long absoluteTimeInMillis() { - return delegate.absoluteTimeInMillis(); + return internalDelegate.absoluteTimeInMillis(); } }