Pinging @elastic/es-core-features (:Core/Features/Java High Level REST Client)

Pinging @elastic/es-core-features (:Core/Features/Indices APIs)

I totally think we could improve the APIs here, and potentially add a builder perhaps to make it easier to build the templates (instead of having to know everything up front) 👍

Hi @dakrone
I wish to take this up.
Kindly confirm if I can start working on this.

@mun-inder-jeet-singh go for it! Let me know if I can of any help

Hi all,

I have the same issue and I face too that rest high client doesn't have a method for put component template.
Anyways, for put a index template from raw json I use this snippet (in Java and with springboot):

PathMatchingResourcePatternResolver resourceLoader = new PathMatchingResourcePatternResolver();
Resource template = resourceLoader.getResources("/templates/your-template.json");
String name = Objects.requireNonNull(template.getFilename()).split("\\.")[0]; //Name from basename of file, in this case your-template
byte[] stringBytes = Files.readAllBytes(Paths.get(template.getURI()));
PutComponentTemplateRequest request = new PutComponentTemplateRequest().name(name);
ComponentTemplate composableIndexTemplate = new ComponentTemplate(StreamInput.wrap(stringBytes));
request.componentTemplate(composableIndexTemplate);

I hope this can be helpfull.

I currently use the legacy IndexTemplates with the "inheritance" mechanism.
During runtime, my application, will read in plain JSON templates from the filesystem and make PutIndexTemplateRequests out of the content using the standard "source(Map<String, Object>)" API available in all Request subclasses to fill the request with the relevant content.

Now, that those templates are becoming legacy stuff, I started evaluating a migration to composite templates ( I think this is a very good concept!).

Now playing with the JAVA HighLevel API here is not very convenient, as there is no simple way to feed an existing JSON into the request. Basically everything must be provided manually in a constructor of ComposableIndexTemplate:

public ComposableIndexTemplate(List<String> indexPatterns, @Nullable Template template, @Nullable List<String> componentTemplates, @Nullable Long priority, @Nullable Long version, @Nullable Map<String, Object> metadata)

which is kind of difficult to use.

It is not very clear how I create a ComponentTemplate or a IndexTemplate using such a component using that API..
I fully understood the "raw" way with HTTP and JSON, but the API does somehow makes it very difficult.

Maybe the API can be improved to match existing APIs.

Addendum:
Of course using the LowLevelClient works fine.

Thanks @dakrone.
I was researching to resolve this and found this code which is present in PutIndexTemplate class.

public PutIndexTemplateRequest settings(Map<String, Object> source) {
try {
XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
builder.map(source);
settings(Strings.toString(builder), XContentType.JSON);
} catch (IOException e) {
throw new ElasticsearchGenerationException("Failed to generate [" + source + "]", e);
}
return this;`` }`

Do we need to create something like this for ComposableIndexTemplate class ?

@mun-inder-jeet-singh I would recommend adding a Builder class inside of the ComposableIndexTemplate class that allows a person to iteratively add the pieces for a template until they call .build() and retrieve the final ComposableIndexTemplate class.

I wouldn't worry too much about adding one that takes a Map<String, Object> for now, as I think that is going to be more error prone.

Was this already solved? Or can i contribute here? @dakrone @mun-inder-jeet-singh

@antrix190 it has not already been solved

@dakrone I would like to give it a try.

Hi @antrix190 , I was working on this issue though, this was my first tryout for opensource, hence taking time to complete this issue.

That's why i asked before picking it up. :)

Can somebody please review my PR?

Hi @dakrone,
I have another approach if its feasible.
Can we add lombok dependency here ? Then We just need to add @builder above the constructor of the class.