2016-11-25 15:42:29 +01:00
|
|
|
package org.gcube.smartgears.provider;
|
|
|
|
|
|
|
|
import static org.gcube.smartgears.Constants.configuration_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.container_configuraton_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.container_profile_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.default_extensions_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.extensions_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.ghn_home_env;
|
|
|
|
import static org.gcube.smartgears.Constants.ghn_home_property;
|
|
|
|
import static org.gcube.smartgears.Constants.library_configuration_file_path;
|
|
|
|
import static org.gcube.smartgears.Constants.profile_file_path;
|
|
|
|
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.FileInputStream;
|
|
|
|
import java.io.InputStream;
|
|
|
|
import java.io.ObjectInputStream;
|
2022-06-10 17:08:44 +02:00
|
|
|
import java.util.ArrayList;
|
2022-05-25 18:56:42 +02:00
|
|
|
import java.util.List;
|
2022-06-10 17:08:44 +02:00
|
|
|
import java.util.Set;
|
2016-11-25 15:42:29 +01:00
|
|
|
import java.util.UUID;
|
2023-02-01 14:40:31 +01:00
|
|
|
import java.util.stream.Collectors;
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
import javax.servlet.ServletContext;
|
2022-03-21 11:17:07 +01:00
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
import org.gcube.common.events.Hub;
|
|
|
|
import org.gcube.common.events.impl.DefaultHub;
|
2023-01-19 16:16:14 +01:00
|
|
|
import org.gcube.common.security.credentials.Credentials;
|
2016-11-25 15:42:29 +01:00
|
|
|
import org.gcube.smartgears.configuration.application.ApplicationConfiguration;
|
|
|
|
import org.gcube.smartgears.configuration.application.ApplicationConfigurationBinder;
|
|
|
|
import org.gcube.smartgears.configuration.application.ApplicationExtensions;
|
|
|
|
import org.gcube.smartgears.configuration.application.ApplicationHandlers;
|
|
|
|
import org.gcube.smartgears.configuration.application.BridgedApplicationConfiguration;
|
|
|
|
import org.gcube.smartgears.configuration.container.ContainerConfiguration;
|
|
|
|
import org.gcube.smartgears.configuration.container.ContainerConfigurationBinder;
|
|
|
|
import org.gcube.smartgears.configuration.library.SmartGearsConfiguration;
|
|
|
|
import org.gcube.smartgears.configuration.library.SmartGearsConfigurationBinder;
|
|
|
|
import org.gcube.smartgears.context.Properties;
|
|
|
|
import org.gcube.smartgears.context.application.ApplicationContext;
|
|
|
|
import org.gcube.smartgears.context.application.DefaultApplicationContext;
|
|
|
|
import org.gcube.smartgears.context.container.ContainerContext;
|
|
|
|
import org.gcube.smartgears.context.container.DefaultContainerContext;
|
2022-05-25 18:56:42 +02:00
|
|
|
import org.gcube.smartgears.handlers.container.ContainerHandler;
|
2016-11-25 15:42:29 +01:00
|
|
|
import org.gcube.smartgears.lifecycle.application.ApplicationLifecycle;
|
|
|
|
import org.gcube.smartgears.lifecycle.container.ContainerLifecycle;
|
2022-06-10 17:08:44 +02:00
|
|
|
import org.gcube.smartgears.publishing.Publisher;
|
|
|
|
import org.gcube.smartgears.publishing.SmartgearsProfilePublisher;
|
2022-03-21 11:17:07 +01:00
|
|
|
import org.gcube.smartgears.security.AuthorizationProvider;
|
2023-01-19 16:16:14 +01:00
|
|
|
import org.gcube.smartgears.security.AuthorizationProviderFactory;
|
2016-11-25 15:42:29 +01:00
|
|
|
import org.gcube.smartgears.utils.Utils;
|
|
|
|
import org.slf4j.Logger;
|
|
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
import io.github.classgraph.ClassGraph;
|
|
|
|
import io.github.classgraph.ClassInfo;
|
|
|
|
import io.github.classgraph.ClassInfoList;
|
|
|
|
import io.github.classgraph.ScanResult;
|
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
/**
|
|
|
|
* Default implementation of the {@link Provider} interface.
|
|
|
|
*
|
|
|
|
* @author Fabio Simeoni
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public class DefaultProvider implements Provider {
|
|
|
|
|
|
|
|
private static Logger log = LoggerFactory.getLogger(Provider.class);
|
2017-05-12 17:18:07 +02:00
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
private ContainerContext containerContext;
|
2023-02-01 14:40:31 +01:00
|
|
|
// TODO: do the same with applicationContext (with a map)
|
2022-03-21 11:17:07 +01:00
|
|
|
|
|
|
|
private File configFile = null;
|
|
|
|
|
|
|
|
protected DefaultProvider(File configFile) {
|
|
|
|
this.configFile = configFile;
|
|
|
|
}
|
2022-05-25 18:56:42 +02:00
|
|
|
|
2022-06-10 17:08:44 +02:00
|
|
|
List<Publisher> publishers;
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
protected DefaultProvider() {
|
|
|
|
};
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public ContainerContext containerContext() {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
if (containerContext == null) {
|
2016-11-25 15:42:29 +01:00
|
|
|
ContainerConfiguration configuration = containerConfiguration();
|
|
|
|
|
|
|
|
Hub hub = new DefaultHub();
|
|
|
|
|
|
|
|
ContainerLifecycle lifecycle = new ContainerLifecycle(hub);
|
|
|
|
|
|
|
|
File file = configuration.persistence().file(container_profile_file_path);
|
|
|
|
|
|
|
|
String id = null;
|
2023-02-01 14:40:31 +01:00
|
|
|
if (file.exists()) {
|
2016-11-25 15:42:29 +01:00
|
|
|
log.info("loading persisted state for container");
|
2023-02-01 14:40:31 +01:00
|
|
|
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
|
|
|
|
id = (String) ois.readObject();
|
|
|
|
} catch (Exception e) {
|
|
|
|
log.error("error loading persisted state, creating new uuid", e);
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
}
|
|
|
|
if (id == null) {
|
2016-11-25 15:42:29 +01:00
|
|
|
id = UUID.randomUUID().toString();
|
2023-02-01 14:40:31 +01:00
|
|
|
log.info("container id created is {}", id);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
}
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
AuthorizationProviderFactory<?> authfactory = configuration.getauthorizationConfiguration()
|
|
|
|
.getAuthProviderFactory();
|
2023-01-19 16:16:14 +01:00
|
|
|
Credentials credentials = configuration.getauthorizationConfiguration().getCredentials();
|
2023-02-01 14:40:31 +01:00
|
|
|
|
2023-01-19 16:16:14 +01:00
|
|
|
AuthorizationProvider authProvider = authfactory.connect(credentials);
|
2023-02-01 14:40:31 +01:00
|
|
|
|
|
|
|
containerContext = new DefaultContainerContext(id, configuration, hub, lifecycle, authProvider,
|
|
|
|
new Properties());
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
|
|
|
return containerContext;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-05-25 18:56:42 +02:00
|
|
|
public List<ContainerHandler> containerHandlers() {
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
ContainerConfigurationBinder binder = new ContainerConfigurationBinder();
|
2022-03-21 11:17:07 +01:00
|
|
|
|
2017-05-12 17:18:07 +02:00
|
|
|
ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader();
|
2023-02-01 14:40:31 +01:00
|
|
|
if (currentClassLoader.getParent() != null
|
|
|
|
&& !currentClassLoader.getParent().equals(ClassLoader.getSystemClassLoader())) {
|
2017-05-12 17:18:07 +02:00
|
|
|
log.trace("probably i'm in a webapp classloader");
|
|
|
|
currentClassLoader = currentClassLoader.getParent();
|
|
|
|
}
|
2022-03-21 11:17:07 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
List<ContainerHandler> defaultHandlers = binder.bindHandlers(currentClassLoader);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2017-05-12 17:18:07 +02:00
|
|
|
return defaultHandlers;
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
} catch (RuntimeException e) {
|
|
|
|
|
|
|
|
throw new RuntimeException("cannot install container handlers (see cause) ", e);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ApplicationContext contextFor(ContainerContext context, ServletContext application) {
|
|
|
|
|
|
|
|
ApplicationConfiguration configuration = null;
|
|
|
|
ApplicationConfiguration embedded = configurationFor(application);
|
|
|
|
ApplicationConfiguration external = context.configuration().app(application.getContextPath());
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
// shouldn't happen: management shouldn't have started at all
|
|
|
|
if (embedded == null && external == null)
|
|
|
|
throw new AssertionError("application @ " + application.getContextPath() + " is not distributed with "
|
|
|
|
+ configuration_file_path + " and there is no external configuration for it in "
|
|
|
|
+ container_configuraton_file_path);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
// no embedded configuration
|
2016-11-25 15:42:29 +01:00
|
|
|
if (embedded == null) {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
configuration = external;
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
log.info("loaded configuration for application " + configuration.name() + " from "
|
|
|
|
+ container_configuraton_file_path);
|
|
|
|
} else {
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
configuration = embedded;
|
|
|
|
|
|
|
|
if (external == null)
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
log.info("loaded configuration for application " + configuration.name() + " from "
|
|
|
|
+ configuration_file_path);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
else {
|
|
|
|
|
|
|
|
configuration.merge(external);
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
log.info("loaded configuration for application " + configuration.name() + " from "
|
|
|
|
+ configuration_file_path + " and " + container_configuraton_file_path);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
}
|
2023-02-01 14:40:31 +01:00
|
|
|
}
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
ApplicationConfiguration bridgedConfiguration = new BridgedApplicationConfiguration(context.configuration(),
|
|
|
|
configuration);
|
|
|
|
|
|
|
|
Hub hub = new DefaultHub();
|
|
|
|
|
|
|
|
ApplicationLifecycle lifecycle = new ApplicationLifecycle(hub, configuration.name());
|
|
|
|
|
|
|
|
File file = bridgedConfiguration.persistence().file(profile_file_path);
|
2023-02-01 14:40:31 +01:00
|
|
|
String id = null;
|
|
|
|
if (file.exists()) {
|
2016-11-25 15:42:29 +01:00
|
|
|
log.info("loading persisted state for application {}", application.getContextPath());
|
2023-02-01 14:40:31 +01:00
|
|
|
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
|
|
|
|
id = (String) ois.readObject();
|
|
|
|
} catch (Exception e) {
|
|
|
|
log.error("error loading persisted state, creating new uuid", e);
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
2023-02-01 14:40:31 +01:00
|
|
|
}
|
|
|
|
if (id == null)
|
2016-11-25 15:42:29 +01:00
|
|
|
id = UUID.randomUUID().toString();
|
|
|
|
|
|
|
|
return new DefaultApplicationContext(id, context, application, bridgedConfiguration, hub, lifecycle,
|
|
|
|
new Properties());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ApplicationHandlers handlersFor(ApplicationContext context) {
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
2017-05-12 17:18:07 +02:00
|
|
|
ApplicationConfigurationBinder binder = new ApplicationConfigurationBinder();
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
// searching for smartegars related application handlers in the common
|
|
|
|
// classloader
|
2017-05-12 17:18:07 +02:00
|
|
|
ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader();
|
2023-02-01 14:40:31 +01:00
|
|
|
if (currentClassLoader.getParent() != null
|
|
|
|
&& !currentClassLoader.getParent().equals(ClassLoader.getSystemClassLoader())) {
|
2017-05-12 17:18:07 +02:00
|
|
|
log.trace("probably i'm in a webapp classloader");
|
|
|
|
currentClassLoader = currentClassLoader.getParent();
|
|
|
|
}
|
2022-03-21 11:17:07 +01:00
|
|
|
|
2022-05-25 18:56:42 +02:00
|
|
|
ApplicationHandlers defaultHandlers = binder.bindHandlers(currentClassLoader);
|
2022-06-10 17:08:44 +02:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
return defaultHandlers;
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
} catch (RuntimeException e) {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
throw new RuntimeException("cannot install handlers for application @ " + context.name() + " (see cause) ",
|
|
|
|
e);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ApplicationExtensions extensionsFor(ApplicationContext context) {
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
InputStream config = context.application().getResourceAsStream(extensions_file_path);
|
|
|
|
|
|
|
|
if (config == null) {
|
|
|
|
|
|
|
|
log.trace("{} uses default extensions as it does not include {}", context.name(), extensions_file_path);
|
|
|
|
|
|
|
|
// it's in a library, using
|
|
|
|
config = getClass().getResourceAsStream(default_extensions_file_path);
|
|
|
|
|
|
|
|
if (config == null)
|
2023-02-01 14:40:31 +01:00
|
|
|
throw new IllegalStateException(
|
|
|
|
"invalid distribution: cannot find " + default_extensions_file_path);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
} else
|
|
|
|
log.info("{} uses custom extensions @ {}", context.name(), extensions_file_path);
|
|
|
|
|
|
|
|
ApplicationConfigurationBinder binder = new ApplicationConfigurationBinder();
|
|
|
|
|
|
|
|
return binder.bindExtensions(config);
|
|
|
|
|
|
|
|
} catch (RuntimeException e) {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
throw new RuntimeException(
|
|
|
|
"cannot install extensions for application @ " + context.name() + " (see cause) ", e);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public SmartGearsConfiguration smartgearsConfiguration() {
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
2022-03-31 11:58:49 +02:00
|
|
|
InputStream config = getClass().getResourceAsStream(library_configuration_file_path);
|
|
|
|
|
|
|
|
if (config == null)
|
|
|
|
throw new IllegalStateException("invalid distribution: cannot find " + library_configuration_file_path);
|
|
|
|
|
|
|
|
SmartGearsConfigurationBinder binder = new SmartGearsConfigurationBinder();
|
|
|
|
|
|
|
|
SmartGearsConfiguration configuration = binder.bind(config);
|
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
configuration.validate();
|
|
|
|
|
|
|
|
return configuration;
|
|
|
|
} catch (RuntimeException e) {
|
|
|
|
|
|
|
|
throw new RuntimeException("cannot read library configuration (see cause) ", e);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// helpers
|
|
|
|
private ApplicationConfiguration configurationFor(ServletContext application) {
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
|
|
InputStream config = application.getResourceAsStream(configuration_file_path);
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
if (config == null)
|
2016-11-25 15:42:29 +01:00
|
|
|
return null;
|
|
|
|
|
|
|
|
ApplicationConfigurationBinder binder = new ApplicationConfigurationBinder();
|
|
|
|
|
|
|
|
return binder.bind(config);
|
|
|
|
|
|
|
|
} catch (RuntimeException e) {
|
|
|
|
|
|
|
|
throw new RuntimeException("invalid configuration (see cause)", e);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private ContainerConfiguration containerConfiguration() {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
if (configFile == null) {
|
2022-05-25 18:56:42 +02:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
String home = Utils.home();
|
2022-05-25 18:56:42 +02:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
if (home == null)
|
|
|
|
throw new IllegalStateException("invalid node configuration: the environment variable " + ghn_home_env
|
|
|
|
+ " or the system property " + ghn_home_property + " must be defined");
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
File homeDir = new File(home);
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
if (!(homeDir.exists() && homeDir.isDirectory() && homeDir.canRead() && homeDir.canWrite()))
|
2023-02-01 14:40:31 +01:00
|
|
|
throw new IllegalStateException("invalid node configuration: home " + home
|
|
|
|
+ " does not exist or is not a directory or cannot be accessed in read/write mode");
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
configFile = new File(homeDir, container_configuraton_file_path);
|
2022-05-25 18:56:42 +02:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
log.trace("reading container configuration @ {} ", configFile.getAbsolutePath());
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
if (!(configFile.exists() && configFile.canRead()))
|
2023-02-01 14:40:31 +01:00
|
|
|
throw new IllegalStateException("invalid node configuration: file " + configFile.getAbsolutePath()
|
|
|
|
+ " does not exist or cannot be accessed");
|
2016-11-25 15:42:29 +01:00
|
|
|
|
2022-03-21 11:17:07 +01:00
|
|
|
ContainerConfiguration configuration;
|
2023-02-01 14:40:31 +01:00
|
|
|
try (InputStream stream = new FileInputStream(configFile)) {
|
|
|
|
configuration = new ContainerConfigurationBinder().load(stream);
|
|
|
|
} catch (Exception e) {
|
|
|
|
throw new IllegalStateException(
|
|
|
|
"invalid node configuration: file " + configFile.getAbsolutePath() + " is invalid", e);
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
2022-05-25 18:56:42 +02:00
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
return configuration;
|
|
|
|
}
|
2017-05-12 17:18:07 +02:00
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
@Override
|
2022-06-10 17:08:44 +02:00
|
|
|
public synchronized List<Publisher> publishers() {
|
|
|
|
if (this.publishers == null) {
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
Set<Class<?>> annotatedPublishers;
|
|
|
|
|
|
|
|
try (ScanResult result = new ClassGraph().enableClassInfo().enableAnnotationInfo()
|
|
|
|
.addClassLoader(Thread.currentThread().getContextClassLoader()).scan()) {
|
|
|
|
|
|
|
|
ClassInfoList classInfos = result.getClassesWithAnnotation(SmartgearsProfilePublisher.class.getName());
|
2022-06-10 17:08:44 +02:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
annotatedPublishers = classInfos.stream().map(ClassInfo::loadClass)
|
|
|
|
.filter(c -> Publisher.class.isAssignableFrom(c)).collect(Collectors.toSet());
|
2022-06-10 17:08:44 +02:00
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Collection<URL> urls =
|
|
|
|
* ClasspathHelper.forClassLoader(Thread.currentThread().getContextClassLoader()
|
|
|
|
* ); urls.removeIf(url -> url.toString().endsWith(".so") ||
|
|
|
|
* url.toString().endsWith(".zip") );
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* ConfigurationBuilder reflectionConf = new
|
|
|
|
* ConfigurationBuilder().addUrls(urls).setScanners(new
|
|
|
|
* TypeAnnotationsScanner(), new SubTypesScanner());
|
|
|
|
*
|
|
|
|
* Reflections reflection = new Reflections(reflectionConf);
|
|
|
|
*
|
|
|
|
* = reflection.getTypesAnnotatedWith(SmartgearsProfilePublisher.class);
|
|
|
|
*/
|
2022-06-10 17:08:44 +02:00
|
|
|
|
|
|
|
List<Publisher> foundPublishers = new ArrayList<Publisher>();
|
2023-02-01 14:40:31 +01:00
|
|
|
for (Class<?> annotatedPublisher : annotatedPublishers) {
|
|
|
|
try {
|
|
|
|
foundPublishers.add((Publisher) annotatedPublisher.getDeclaredConstructor().newInstance());
|
|
|
|
log.info("added class {} to publishers", annotatedPublisher);
|
|
|
|
} catch (Throwable e) {
|
|
|
|
log.error("publisher class {} cannot be instantiated", annotatedPublisher.getCanonicalName(), e);
|
|
|
|
}
|
|
|
|
|
2022-06-10 17:08:44 +02:00
|
|
|
}
|
|
|
|
this.publishers = foundPublishers;
|
|
|
|
|
|
|
|
if (foundPublishers.isEmpty())
|
|
|
|
log.warn("no publishers found in classloader");
|
|
|
|
}
|
2023-02-01 14:40:31 +01:00
|
|
|
|
2022-06-10 17:08:44 +02:00
|
|
|
return this.publishers;
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|
|
|
|
|
2023-02-01 14:40:31 +01:00
|
|
|
/*
|
|
|
|
* @Override public AuthorizationProvider authorizationProvider() { return
|
|
|
|
* containerContext.authorizationProvider(); }
|
|
|
|
*/
|
|
|
|
|
2016-11-25 15:42:29 +01:00
|
|
|
}
|