207 lines
7.1 KiB
Java
207 lines
7.1 KiB
Java
/*-
|
|
* ~~~~~~licensing~~~~~~
|
|
* adapters-core
|
|
* ==========
|
|
* Copyright (C) 2020 - 2023 EmDev LLC
|
|
* ==========
|
|
* You may not use this file except in accordance with the License Terms of the Copyright
|
|
* Holder located at: https://entaxy.ru/eula . All copyrights, all intellectual property
|
|
* rights to the Software and any copies are the property of the Copyright Holder. Unless
|
|
* it is explicitly allowed the Copyright Holder, the User is prohibited from using the
|
|
* Software for commercial purposes to provide services to third parties.
|
|
*
|
|
* The Copyright Holder hereby declares that the Software is provided on an "AS IS".
|
|
* Under no circumstances does the Copyright Holder guarantee or promise that the
|
|
* Software provided by him will be suitable or not suitable for the specific purposes
|
|
* of the User, that the Software will meet all commercial and personal subjective
|
|
* expectations of the User, that the Software will work properly, without technical
|
|
* errors, quickly and uninterruptedly.
|
|
*
|
|
* Under no circumstances shall the Copyright Holder or its Affiliates is not liable
|
|
* to the User for any direct or indirect losses of the User, his expenses or actual
|
|
* damage, including, downtime; loss of bussines; lost profit; lost earnings; loss
|
|
* or damage to data, property, etc.
|
|
* ~~~~~~/licensing~~~~~~
|
|
*/
|
|
package ru.entaxy.esb.platform.runtime.base.connecting.adapter.core.impl;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.net.URL;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.osgi.framework.BundleContext;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
import com.google.gson.JsonElement;
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.JsonParser;
|
|
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.adapter.core.api.Adapter;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.adapter.core.metadata.AdapterFieldElement;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.adapter.core.metadata.AdapterGeneratorElement;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.adapter.core.metadata.AdapterMetadataElement;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.generator.Generated;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.generator.Generator;
|
|
import ru.entaxy.esb.platform.runtime.base.connecting.generator.factory.GeneratorFactory;
|
|
|
|
public class DefaultAdapter implements Adapter {
|
|
|
|
protected static final Logger log = LoggerFactory.getLogger(DefaultAdapter.class);
|
|
|
|
protected BundleContext bundleContext;
|
|
|
|
protected boolean isInited = false;
|
|
protected String defaultId = "none";
|
|
protected String defaultName = "Undefined";
|
|
protected String defaultDescription = "Undefined";
|
|
protected AdapterMetadataElement adapterMetadata;
|
|
|
|
@Deprecated
|
|
protected Map<String, Generator> generatorList = new HashMap<>();
|
|
protected Map<String, GeneratorDescriptor> generatorDescriptorList = new HashMap<>();
|
|
|
|
protected static class GeneratorDescriptor {
|
|
BundleContext bundleContext;
|
|
AdapterGeneratorElement generatorElement;
|
|
Generator generator;
|
|
boolean linked = false;
|
|
|
|
public void linkGenerator() {
|
|
generator = GeneratorFactory.createGenerator(generatorElement.getGenerator()
|
|
, generatorElement.getType(), bundleContext);
|
|
linked = (generator != null);
|
|
}
|
|
|
|
}
|
|
|
|
public DefaultAdapter(BundleContext bundleContext) throws IOException {
|
|
this.bundleContext = bundleContext;
|
|
log.debug("Constructor of adapter {}", DefaultAdapter.class.getName());
|
|
this.isInited = this.init();
|
|
}
|
|
|
|
protected boolean init() throws IOException {
|
|
URL metadataUrl = this.bundleContext.getBundle().getEntry("/ru/entaxy/adapter/metadata.json");
|
|
log.debug("Json URL is {}", metadataUrl.toString());
|
|
|
|
String metadata = new BufferedReader (
|
|
new InputStreamReader(
|
|
metadataUrl.openStream(), StandardCharsets.UTF_8))
|
|
.lines()
|
|
.collect(Collectors.joining("\n"));
|
|
|
|
log.debug("Adapter json description: \n" + metadata);
|
|
|
|
GsonBuilder builder = new GsonBuilder();
|
|
Gson gson = builder.create();
|
|
|
|
JsonElement je = (new JsonParser()).parse(metadata);
|
|
JsonObject root = je.getAsJsonObject();
|
|
|
|
JsonElement adapterElement = root.get("adapter");
|
|
|
|
this.adapterMetadata = gson.fromJson(adapterElement, AdapterMetadataElement.class);
|
|
|
|
List<AdapterGeneratorElement> generators = adapterMetadata.getGenerators();
|
|
|
|
for (AdapterGeneratorElement generator: generators) {
|
|
GeneratorDescriptor descriptor = new GeneratorDescriptor();
|
|
descriptor.bundleContext = this.bundleContext;
|
|
descriptor.generatorElement = generator;
|
|
if (!generator.isLazy())
|
|
descriptor.linkGenerator();
|
|
this.generatorDescriptorList.put(generator.getType(), descriptor);
|
|
}
|
|
|
|
// initGenerators(adapterMetadata.getGenerators());
|
|
|
|
return this.adapterMetadata != null && !generatorDescriptorList.isEmpty();
|
|
}
|
|
|
|
private void initGenerators(List<AdapterGeneratorElement> generators) {
|
|
for (AdapterGeneratorElement generator: generators) {
|
|
String usageType = generator.getType();
|
|
String generatorType = generator.getGenerator();
|
|
generatorList.put(usageType,
|
|
GeneratorFactory.createGenerator(generatorType, usageType, bundleContext));
|
|
}
|
|
log.debug("generatorList: " + generatorList);
|
|
//TODO checkGeneratorList();
|
|
}
|
|
|
|
/* Interface */
|
|
|
|
@Override
|
|
public boolean isInited() {
|
|
return isInited;
|
|
}
|
|
|
|
@Override
|
|
public String getId() {
|
|
return this.isInited?this.adapterMetadata.getId():this.defaultId;
|
|
}
|
|
|
|
public void setId(String id) {
|
|
this.adapterMetadata.setId(id);
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return this.isInited?this.adapterMetadata.getName():this.defaultName;
|
|
}
|
|
|
|
public void setName(String name) {
|
|
this.adapterMetadata.setName(name);
|
|
}
|
|
|
|
@Override
|
|
public String getDescription() {
|
|
return this.isInited?this.adapterMetadata.getDescription():this.defaultDescription;
|
|
}
|
|
|
|
public void setDescription(String description) {
|
|
this.adapterMetadata.setDescription(description);
|
|
}
|
|
|
|
@Override
|
|
public Map<String, String> getProperties(){
|
|
return this.adapterMetadata.getFields()
|
|
.stream()
|
|
.filter(field -> field.isProperty())
|
|
.collect(Collectors.toMap(AdapterFieldElement::getName, AdapterFieldElement::getType));
|
|
}
|
|
|
|
@Override
|
|
public Map<String, String> getOptions(){
|
|
return this.adapterMetadata.getFields()
|
|
.stream()
|
|
.filter(field -> field.isOption())
|
|
.collect(Collectors.toMap(AdapterFieldElement::getName, AdapterFieldElement::getType));
|
|
}
|
|
|
|
@Override
|
|
public Generated generate(String type, Map<String, Object> map) throws Exception {
|
|
GeneratorDescriptor descriptor = generatorDescriptorList.get(type);
|
|
if (descriptor == null)
|
|
throw new NoSuchElementException("Generator of type ["
|
|
+ type + "] not defined for adapter [" + this.getId() + "]");
|
|
if (!descriptor.linked)
|
|
descriptor.linkGenerator();
|
|
if (!descriptor.linked)
|
|
throw new NoSuchElementException("Generator of type ["
|
|
+ type + "] not linked for adapter [" + this.getId() + "]");
|
|
Generator generator = descriptor.generator;
|
|
return generator.generate(map);
|
|
}
|
|
}
|