[Refactor] *Plugin classes in modules/ source module to *Module classes

[nknize]

Is your feature request related to a problem? Please describe.
OpenSearch modules only differ from plugins in that they are installed by default. Aside from that the same plugin scaffolding is used between the two. This makes navigating the source tree difficult. For example, if I'm looking at IngestUserAgentPlugin and IngestAttachmentPlugin I'd have no way of knowing IngestUserAgentPlugin is a module and IngestAttachment is a plugin. (missing javadocs aside).

Describe the solution you'd like
I propose we rote refactor all derived *Plugin classes currently in the modules/ directory to *Module to make it more clear which concrete plugin classes are installed by default vs which are not.

Describe alternatives you've considered
Implement separate module and plugin base classes. I think this is overkill for something that works just fine today and will likely be reworked during the extensions effort.

Additional context
This is a good low hanging fruit effort that a community contributor could pick up for earning merit.

[andrross]

Just thinking out loud, but what about getting rid of the different source tree all together by moving modules under the plugin directory? The "installed by default" property feels like an external configuration and not something fundamental about the module itself. In this proposal we'd have all plugins under the same source tree and then a configuration defined somewhere in a build file (presumably?) that chooses which plugins get installed by default. If we ever change which plugins are installed by default it becomes a simple configuration change with no moving around or renaming of source files.

[nknize]

The "installed by default" property feels like an external configuration and not something fundamental about the module itself.

I don't believe it's an external configuration. I'll have to double check but I believe modules under that directory are auto-installed by the PluginService at bootstrap but plugins under the plugins directory are not (users have to use the InstallPlugin CLI). There is a runtime dependency that we would be breaking if we eliminated the directory. I'm hoping to avoid all that with this simple low hanging fruit issue and just refactor the class names to be more explicit between the auto installed modules vs plugins.

[rockybean]

Seems like an easy task and I'd like to give this a try.

[reta]

@nknize to be fair, this change would make the codebase navigation obscure, at least from developer's standpoint. When I am looking for plugin classes, I just do *Plugin and that's about it (may be it's just me).

Another, more serious problem is confusion with CDI, notably org.opensearch.common.inject.Module (and we have tons of them in the core). Those are indeed modules, not plugins, with this change we would make such distinction quite messy.

To sum up, I am strongly -1 on this idea (sorry about that).

[nknize]

To sum up, I am strongly -1 on this idea (sorry about that).

These are reasonable concerns so no apology necessary.

this change would make the codebase navigation obscure...When I am looking for plugin classes, I just do *Plugin and that's about it

I think this is the problem I'm finding. Using the *Plugin nomenclature provides no developer distinction between those that are modules (installed by default) vs those that are Plugins; and this is causing confusion.

Another, more serious problem is confusion with CDI, notably org.opensearch.common.inject.Module

I agree that the term module is so overloaded here since java modules and the jigsaw framework uses the same vernacular. I think there's a longer term solution to this with extensibility other than the simple rote refactor proposed here. In the meantime I'm looking for something that will solve the third-party confusion of plugins vs core modules beyond the answer "they logically live in the core repository and are shipped with the min distribution".

Would a compromise be to refactor to *ModulePlugin or *PluginModule; e.g., IngestUserAgentPluginModule vs IngestAttachmentPlugin? (feels like a mouth of marbles).

[reta]

Would a compromise be to refactor to *ModulePlugin or *PluginModule; e.g., IngestUserAgentPluginModule vs IngestAttachmentPlugin? (feels like a mouth of marbles).

I think *ModulePlugin (or *BundledPlugin / *InternalPlugin / ...) would be a reasonable compromise, thank you.