ISPN-10407 Representation of the CacheManager configuration as JSON

commons/src/main/java/org/infinispan/commons/configuration/JsonWriter.java

@@ -1,6 +1,9 @@
 package org.infinispan.commons.configuration;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 import org.infinispan.commons.CacheConfigurationException;
@@ -41,17 +44,17 @@ void writeElement(Json parent, ConfigurationInfo element, boolean renderName) {
          writeAttributes(body, attributes, element);
       }
 
-      if (isArray(childElements)) {
-         writeArray(body, element, childElements);
-      } else {
-         for (ConfigurationInfo subElement : childElements) {
+      Map<String, List<ConfigurationInfo>> elementsByName = groupElementsByName(childElements);
+      elementsByName.forEach((name, cfg) -> {
+         if (cfg.size() > 1) {
+            writeArray(body, element, cfg);
+         } else {
+            ConfigurationInfo subElement = cfg.iterator().next();
             ElementDefinition definition = subElement.getElementDefinition();
-            if (definition != null) {
-               writeElement(body, subElement, definition.isTopLevel());
-            }
+            writeElement(body, subElement, definition.isTopLevel());
          }
-      }
-      if (!body.asJsonMap().isEmpty()) {
+      });
+      if (!body.asJsonMap().isEmpty() || !configurationElement.omitIfEmpty()) {
          if (renderName) {
             String name = elementOutput.getName();
             Json existingElement = parent.at(name);
@@ -80,7 +83,6 @@ private void writeAttributes(Json parent, AttributeSet attributeSet, Configurati
 
       for (Attribute<?> attribute : attributeSet.attributes()) {
          boolean isPersistent = attribute.isPersistent();
-         attribute.getAttributeDefinition().getSerializerConfig();
          AttributeSerializer serializerConfig = attribute.getAttributeDefinition().getSerializerConfig();
          String topLevelElement = serializerConfig.getParentElement(element);
          String attrName = serializerConfig.getSerializationName(attribute, element);
@@ -105,16 +107,16 @@ private void writeAttributes(Json parent, AttributeSet attributeSet, Configurati
       if (json != null) parent.asJsonMap().putAll(json.asJsonMap());
    }
 
-   private boolean isArray(List<ConfigurationInfo> configurationInfos) {
-      if (configurationInfos.size() < 2) return false;
-
-      ConfigurationInfo first = configurationInfos.iterator().next();
-      ElementDefinition elementDefinition = first.getElementDefinition();
-      if (elementDefinition == null) return false;
-
-      String firstElementName = elementDefinition.toExternalName(first).getName();
-      return configurationInfos.stream()
-            .allMatch(c -> c.getElementDefinition() != null && c.getElementDefinition().toExternalName(c).getName().equals(firstElementName));
+   private Map<String, List<ConfigurationInfo>> groupElementsByName(List<ConfigurationInfo> configurationInfos) {
+      Map<String, List<ConfigurationInfo>> configsByName = new LinkedHashMap<>();
+      configurationInfos.forEach(c -> {
+         ElementDefinition elementDefinition = c.getElementDefinition();
+         if (elementDefinition != null) {
+            String elementName = elementDefinition.toExternalName(c).getName();
+            configsByName.computeIfAbsent(elementName, v -> new ArrayList<>()).add(c);
+         }
+      });
+      return configsByName;
    }
 
 }

commons/src/main/java/org/infinispan/commons/configuration/elements/DefaultElementDefinition.java

@@ -6,15 +6,25 @@ public class DefaultElementDefinition<C extends ConfigurationInfo> implements El
 
    private final String name;
    private final boolean isTopLevel;
+   private final boolean omitIfEmpty;
 
    public DefaultElementDefinition(String name, boolean isTopLevel) {
+      this(name, isTopLevel, true);
+   }
+
+   public DefaultElementDefinition(String name, boolean isTopLevel, boolean omitIfEmpty) {
       this.name = name;
       this.isTopLevel = isTopLevel;
+      this.omitIfEmpty = omitIfEmpty;
    }
 
    public DefaultElementDefinition(String name) {
-      this.name = name;
-      this.isTopLevel = true;
+      this(name, true, true);
+   }
+
+   @Override
+   public boolean omitIfEmpty() {
+      return omitIfEmpty;
    }
 
    @Override

commons/src/main/java/org/infinispan/commons/configuration/elements/ElementDefinition.java

@@ -23,6 +23,10 @@ public interface ElementDefinition<C extends ConfigurationInfo> {
     */
    ElementOutput toExternalName(C configuration);
 
+   default boolean omitIfEmpty() {
+      return true;
+   }
+
    /**
     * @return true if the attributeName inside the element is not mapped to any {@link Attribute}, but
     * as a helper to identify the element when reading it back.

core/pom.xml

@@ -98,6 +98,11 @@
          <artifactId>hamcrest-core</artifactId>
          <scope>test</scope>
       </dependency>
+       <dependency>
+           <groupId>com.fasterxml.jackson.core</groupId>
+           <artifactId>jackson-databind</artifactId>
+           <scope>test</scope>
+       </dependency>
 
       <dependency>
          <groupId>org.apache.commons</groupId>

core/src/main/java/org/infinispan/configuration/cache/AuthorizationConfiguration.java

@@ -8,7 +8,6 @@
 import org.infinispan.commons.configuration.ConfigurationInfo;
 import org.infinispan.commons.configuration.attributes.Attribute;
 import org.infinispan.commons.configuration.attributes.AttributeDefinition;
-import org.infinispan.commons.configuration.attributes.AttributeInitializer;
 import org.infinispan.commons.configuration.attributes.AttributeSet;
 import org.infinispan.commons.configuration.elements.DefaultElementDefinition;
 import org.infinispan.commons.configuration.elements.ElementDefinition;
@@ -21,12 +20,7 @@
  */
 public class AuthorizationConfiguration implements ConfigurationInfo {
    public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder("enabled", false).immutable().build();
-   public static final AttributeDefinition<Set> ROLES = AttributeDefinition.builder("roles", null, Set.class).initializer(new AttributeInitializer<Set>() {
-      @Override
-      public Set initialize() {
-         return new HashSet<String>();
-      }
-   }).build();
+   public static final AttributeDefinition<Set> ROLES = AttributeDefinition.builder("roles", null, Set.class).initializer(HashSet::new).build();
 
    static final AttributeSet attributeDefinitionSet() {
       return new AttributeSet(AuthorizationConfiguration.class, ENABLED, ROLES);

core/src/main/java/org/infinispan/configuration/global/BoundedThreadPoolConfiguration.java

@@ -0,0 +1,86 @@
+package org.infinispan.configuration.global;
+
+import org.infinispan.commons.configuration.ConfigurationInfo;
+import org.infinispan.commons.configuration.attributes.Attribute;
+import org.infinispan.commons.configuration.attributes.AttributeDefinition;
+import org.infinispan.commons.configuration.attributes.AttributeSet;
+import org.infinispan.commons.configuration.elements.DefaultElementDefinition;
+import org.infinispan.commons.configuration.elements.ElementDefinition;
+import org.infinispan.configuration.parsing.Element;
+
+/**
+ * @since 10.0
+ */
+class BoundedThreadPoolConfiguration implements ConfigurationInfo {
+   static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).build();
+   static final AttributeDefinition<String> THREAD_FACTORY = AttributeDefinition.builder("threadFactory", null, String.class).build();
+   static final AttributeDefinition<Integer> MAX_THREADS = AttributeDefinition.builder("maxThreads", null, Integer.class).build();
+   static final AttributeDefinition<Integer> CORE_THREADS = AttributeDefinition.builder("coreThreads", null, Integer.class).build();
+   static final AttributeDefinition<Long> KEEP_ALIVE_TIME = AttributeDefinition.builder("keepAliveTime", null, Long.class).build();
+   static final AttributeDefinition<Integer> QUEUE_LENGTH = AttributeDefinition.builder("queue-length", null, Integer.class).build();
+
+   private final AttributeSet attributes;
+   private final Attribute<String> name;
+   private final Attribute<String> threadFactory;
+   private final Attribute<Integer> maxThreads;
+   private final Attribute<Integer> coreThreads;
+   private final Attribute<Long> keepAliveTime;
+   private final Attribute<Integer> queueLength;
+
+   public static AttributeSet attributeDefinitionSet() {
+      return new AttributeSet(BoundedThreadPoolConfiguration.class, NAME, THREAD_FACTORY, MAX_THREADS, CORE_THREADS, KEEP_ALIVE_TIME, QUEUE_LENGTH);
+   }
+
+   static ElementDefinition ELEMENT_DEFINITION = new DefaultElementDefinition(Element.BLOCKING_BOUNDED_QUEUE_THREAD_POOL.getLocalName());
+
+   BoundedThreadPoolConfiguration(AttributeSet attributes) {
+      this.attributes = attributes.checkProtection();
+      this.name = attributes.attribute(NAME);
+      this.threadFactory = attributes.attribute(THREAD_FACTORY);
+      this.maxThreads = attributes.attribute(MAX_THREADS);
+      this.coreThreads = attributes.attribute(CORE_THREADS);
+      this.keepAliveTime = attributes.attribute(KEEP_ALIVE_TIME);
+      this.queueLength = attributes.attribute(QUEUE_LENGTH);
+   }
+
+   @Override
+   public ElementDefinition getElementDefinition() {
+      return ELEMENT_DEFINITION;
+   }
+
+   public AttributeSet attributes() {
+      return attributes;
+   }
+
+   public String name() {
+      return name.get();
+   }
+
+   public String threadFactory() {
+      return threadFactory.get();
+   }
+
+   public Integer getMaxThreads() {
+      return maxThreads.get();
+   }
+
+   public Integer getCoreThreads() {
+      return coreThreads.get();
+   }
+
+   public Long getKeepAliveTime() {
+      return keepAliveTime.get();
+   }
+
+   public Integer getQueueLength() {
+      return queueLength.get();
+   }
+
+   @Override
+   public String toString() {
+      return "BoundedThreadPoolConfiguration{" +
+            "attributes=" + attributes +
+            '}';
+   }
+
+}

core/src/main/java/org/infinispan/configuration/global/BoundedThreadPoolConfigurationBuilder.java

@@ -0,0 +1,111 @@
+package org.infinispan.configuration.global;
+
+import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.CORE_THREADS;
+import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.KEEP_ALIVE_TIME;
+import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.MAX_THREADS;
+import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.QUEUE_LENGTH;
+import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.NAME;
+import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.THREAD_FACTORY;
+
+import org.infinispan.commons.configuration.Builder;
+import org.infinispan.commons.configuration.attributes.AttributeSet;
+import org.infinispan.commons.executors.BlockingThreadPoolExecutorFactory;
+import org.infinispan.factories.threads.DefaultThreadFactory;
+
+/*
+ * @since 10.0
+ */
+public class BoundedThreadPoolConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<BoundedThreadPoolConfiguration>, ThreadPoolBuilderAdapter {
+   private final AttributeSet attributes;
+
+   BoundedThreadPoolConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String name) {
+      super(globalConfig);
+      attributes = BoundedThreadPoolConfiguration.attributeDefinitionSet();
+      attributes.attribute(NAME).set(name);
+
+   }
+
+   public AttributeSet attributes() {
+      return attributes;
+   }
+
+   public BoundedThreadPoolConfigurationBuilder threadFactory(String threadFactory) {
+      attributes.attribute(THREAD_FACTORY).set(threadFactory);
+      return this;
+   }
+
+   public BoundedThreadPoolConfigurationBuilder maxThreads(Integer maxThreads) {
+      attributes.attribute(MAX_THREADS).set(maxThreads);
+      return this;
+   }
+
+   public Integer maxThreads() {
+      return attributes.attribute(MAX_THREADS).get();
+   }
+
+   public BoundedThreadPoolConfigurationBuilder coreThreads(Integer coreThreads) {
+      attributes.attribute(CORE_THREADS).set(coreThreads);
+      return this;
+   }
+
+   public Integer coreThreads() {
+      return attributes.attribute(CORE_THREADS).get();
+   }
+
+   public BoundedThreadPoolConfigurationBuilder keepAliveTime(Long keepAlive) {
+      attributes.attribute(KEEP_ALIVE_TIME).set(keepAlive);
+      return this;
+   }
+
+   public Long keepAliveTime() {
+      return attributes.attribute(KEEP_ALIVE_TIME).get();
+   }
+
+   public BoundedThreadPoolConfigurationBuilder queueLength(Integer queueLength) {
+      attributes.attribute(QUEUE_LENGTH).set(queueLength);
+      return this;
+   }
+
+   public Integer queueLength() {
+      return attributes.attribute(QUEUE_LENGTH).get();
+   }
+
+   public String name() {
+      return attributes.attribute(NAME).get();
+   }
+
+   @Override
+   public void validate() {
+   }
+
+   @Override
+   public BoundedThreadPoolConfiguration create() {
+      return new BoundedThreadPoolConfiguration(attributes.protect());
+   }
+
+   @Override
+   public BoundedThreadPoolConfigurationBuilder read(BoundedThreadPoolConfiguration template) {
+      attributes.read(template.attributes());
+      return this;
+   }
+
+   public String threadFactory() {
+      return attributes.attribute(THREAD_FACTORY).get();
+   }
+
+   @Override
+   public String toString() {
+      return "BoundedThreadPoolConfigurationBuilder{" +
+            "attributes=" + attributes +
+            '}';
+   }
+
+   @Override
+   public ThreadPoolConfiguration asThreadPoolConfigurationBuilder() {
+      ThreadPoolConfigurationBuilder builder = new ThreadPoolConfigurationBuilder(getGlobalConfig());
+      builder.threadPoolFactory(new BlockingThreadPoolExecutorFactory(maxThreads(), coreThreads(), queueLength(), keepAliveTime()));
+      DefaultThreadFactory threadFactory = getGlobalConfig().threads().getThreadFactory(threadFactory()).create().getThreadFactory();
+      builder.threadFactory(threadFactory);
+      return builder.create();
+   }
+}