KOGITO-6685 Changed to configure Circuit Breaker using MicroProfile properties

Signed-off-by: Helber Belmiro <[email protected]>

Author: hbelmiro

README.md

@@ -154,8 +154,8 @@ The API Key scheme has an additional property that requires where to add the API
 
 ## Circuit Breaker
 
-You can add [CircuitBreaker annotation from MicroProfile Fault Tolerance](https://microprofile.io/project/eclipse/microprofile-fault-tolerance/spec/src/main/asciidoc/circuitbreaker.asciidoc)
-to your generated classes by defining the desired configuration in `application.properties`.
+You can define the [CircuitBreaker annotation from MicroProfile Fault Tolerance](https://microprofile.io/project/eclipse/microprofile-fault-tolerance/spec/src/main/asciidoc/circuitbreaker.asciidoc)
+in your generated classes by setting the desired configuration in `application.properties`.
 
 Let's say you have the following OpenAPI definition:
 ````json
@@ -182,7 +182,6 @@ Let's say you have the following OpenAPI definition:
         }
       }
     },
-
     "/bye": {
       "get": {
         "responses": {
@@ -217,39 +216,35 @@ Add the [SmallRye Fault Tolerance extension](https://quarkus.io/guides/smallrye-
 Assuming your Open API spec file is in `src/main/openapi/simple-openapi.json`, add the following configuration to your `application.properties` file:
 
 ````properties
-quarkus.openapi-generator.spec."simple-openapi.json".base-package=org.acme.openapi.simple
-
-# Enables the CircuitBreaker extension
-quarkus.openapi-generator.CircuitBreaker.enabled=true
-
-# Defines the configuration for the GET method to the /bye endpoint
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/failOn = java.lang.IllegalArgumentException,java.lang.NullPointerException
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/skipOn = java.lang.NumberFormatException
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/delay = 33
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/delayUnit = MILLIS
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/requestVolumeThreshold = 42
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/failureRatio = 3.14
-quarkus.openapi-generator.spec."simple-openapi.json"/byeGet/CircuitBreaker/successThreshold = 22
+quarkus.openapi-generator.codegen.spec."simple-openapi.json".base-package=org.acme.openapi.simple
+
+# Enables the CircuitBreaker extension for the byeGet method from the DefaultApi class
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/enabled=true
 ````
 
 With the above configuration, your Rest Clients will be created with a code similar to the following:
 
 ````java
+package org.acme.openapi.simple.api;
+
+import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.Map;
+import javax.ws.rs.*;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.MediaType;
+
 @Path("")
 @RegisterRestClient
 public interface DefaultApi {
 
     @GET
     @Path("/bye")
     @Produces({"text/plain"})
-    @org.eclipse.microprofile.faulttolerance.CircuitBreaker(
-            delay = 33, 
-            delayUnit = java.time.temporal.ChronoUnit.MILLIS, 
-            failOn = { java.lang.IllegalArgumentException.class, java.lang.NullPointerException.class }, 
-            failureRatio = 3.14, 
-            requestVolumeThreshold = 42, 
-            skipOn = java.lang.NumberFormatException.class, 
-            successThreshold = 22)
+    @org.eclipse.microprofile.faulttolerance.CircuitBreaker
     public String byeGet();
 
     @GET
@@ -260,6 +255,19 @@ public interface DefaultApi {
 }
 ````
 
+You can also override the default Circuit Breaker configuration by setting the properties in `application.properties` [just as you would for a traditional MicroProfile application](https://quarkus.io/guides/smallrye-fault-tolerance#runtime-configuration):
+
+````properties
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/failOn = java.lang.IllegalArgumentException,java.lang.NullPointerException
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/skipOn = java.lang.NumberFormatException
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/delay = 33
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/delayUnit = MILLIS
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/requestVolumeThreshold = 42
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/failureRatio = 3.14
+org.acme.openapi.simple.api.DefaultApi/byeGet/CircuitBreaker/successThreshold = 22
+````
+
+
 ## Known Limitations
 
 These are the known limitations of this pre-release version:

deployment/src/main/java/io/quarkiverse/openapi/generator/deployment/circuitbreaker/CircuitBreakerConfiguration.java

@@ -1,105 +1,43 @@
 package io.quarkiverse.openapi.generator.deployment.circuitbreaker;
 
 import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public final class CircuitBreakerConfiguration {
 
-    private static final CircuitBreakerConfiguration EMPTY = CircuitBreakerConfiguration.builder()
-            .enabled(false)
-            .operations(List.of())
-            .build();
+    private final List<CircuitBreakerClassConfiguration> classConfigurations;
 
-    private final Boolean enabled;
-
-    private final List<Operation> operations;
-
-    private CircuitBreakerConfiguration(Builder builder) {
-        enabled = Objects.requireNonNull(builder.enabled);
-        operations = Objects.requireNonNull(builder.operations);
+    public CircuitBreakerConfiguration(List<CircuitBreakerClassConfiguration> classConfigurations) {
+        this.classConfigurations = List.copyOf(classConfigurations);
     }
 
-    public Boolean getEnabled() {
-        return enabled;
+    public List<CircuitBreakerClassConfiguration> getClassConfigurations() {
+        return classConfigurations;
     }
 
-    public List<Operation> getOperations() {
-        return operations;
+    CircuitBreakerClassConfiguration getClassConfiguration(String className) {
+        return getClassConfigurations().stream()
+                .filter(c -> c.getClassName().equals(className))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("Configuration not found for class: " + className));
     }
 
-    public static CircuitBreakerConfiguration empty() {
-        return EMPTY;
-    }
-
-    public static Builder builder() {
-        return new Builder();
-    }
+    public static final class CircuitBreakerClassConfiguration {
 
-    public static final class Operation {
-        private final String name;
-        private final Map<String, String> attributes;
-
-        public Operation(String name, Map<String, String> attributes) {
-            this.name = Objects.requireNonNull(name);
-            this.attributes = Objects.requireNonNull(attributes);
-        }
-
-        public String getName() {
-            return name;
-        }
+        private final String className;
 
-        public Map<String, String> getAttributes() {
-            return attributes;
-        }
-
-        public String getAttributesAsString() {
-            return attributes.entrySet().stream()
-                    .sorted(Map.Entry.comparingByKey())
-                    .map(entry -> {
-                        switch (entry.getKey()) {
-                            case "failOn":
-                            case "skipOn":
-                                List<String> classes = Stream.of(entry.getValue().split(","))
-                                        .map(String::trim)
-                                        .map(value -> value + ".class")
-                                        .collect(Collectors.toUnmodifiableList());
-
-                                if (classes.size() == 1) {
-                                    return entry.getKey() + " = " + classes.get(0);
-                                } else {
-                                    return entry.getKey() + " = { " + String.join(", ", classes) + " }";
-                                }
-                            case "delayUnit":
-                                return "delayUnit = java.time.temporal.ChronoUnit." + entry.getValue();
-                            default:
-                                return entry.getKey() + " = " + entry.getValue().trim();
-                        }
-                    }).collect(Collectors.joining(", "));
-        }
-    }
-
-    public static final class Builder {
-        private List<Operation> operations;
-        private Boolean enabled;
-
-        private Builder() {
-        }
+        private final List<String> methods;
 
-        public Builder enabled(boolean enabled) {
-            this.enabled = enabled;
-            return this;
+        public CircuitBreakerClassConfiguration(String className, List<String> methods) {
+            this.className = className;
+            this.methods = List.copyOf(methods);
         }
 
-        public Builder operations(List<Operation> operations) {
-            this.operations = List.copyOf(operations);
-            return this;
+        public String getClassName() {
+            return className;
         }
 
-        public CircuitBreakerConfiguration build() {
-            return new CircuitBreakerConfiguration(this);
+        public List<String> getMethods() {
+            return methods;
         }
     }
 }

deployment/src/main/java/io/quarkiverse/openapi/generator/deployment/circuitbreaker/CircuitBreakerConfigurationParser.java

@@ -1,74 +1,59 @@
 package io.quarkiverse.openapi.generator.deployment.circuitbreaker;
 
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
+import java.util.Set;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
-public final class CircuitBreakerConfigurationParser {
-
-    private static final String CONFIG_PREFIX = "quarkus.openapi-generator.spec.";
-
-    private static final String PROPERTY_REGEX = CONFIG_PREFIX + "\".+\"/.+/CircuitBreaker/.+";
+import io.quarkiverse.openapi.generator.deployment.circuitbreaker.CircuitBreakerConfiguration.CircuitBreakerClassConfiguration;
 
-    private static final String CIRCUIT_BREAKER_ENABLED_PROPERTY_NAME = "quarkus.openapi-generator.CircuitBreaker.enabled";
+public final class CircuitBreakerConfigurationParser {
 
     private final UnaryOperator<String> nameToValuePropertyMapper;
 
-    private final String openApiFileName;
-
-    private final int operationIndex;
-
-    public CircuitBreakerConfigurationParser(String openApiFileName, UnaryOperator<String> nameToValuePropertyMapper) {
-        this.openApiFileName = openApiFileName;
+    public CircuitBreakerConfigurationParser(UnaryOperator<String> nameToValuePropertyMapper) {
         this.nameToValuePropertyMapper = nameToValuePropertyMapper;
-        operationIndex = CONFIG_PREFIX.length() + openApiFileName.length() + 3;
     }
 
     public CircuitBreakerConfiguration parse(Collection<String> propertyNames) {
-        if (propertyNames.contains(CIRCUIT_BREAKER_ENABLED_PROPERTY_NAME)
-                && Boolean.parseBoolean(nameToValuePropertyMapper.apply(CIRCUIT_BREAKER_ENABLED_PROPERTY_NAME))) {
-            return CircuitBreakerConfiguration.builder()
-                    .enabled(true)
-                    .operations(getOperations(propertyNames))
-                    .build();
-        } else {
-            return CircuitBreakerConfiguration.empty();
-        }
+        return new CircuitBreakerConfiguration(readClasses(propertyNames));
     }
 
-    private List<CircuitBreakerConfiguration.Operation> getOperations(Collection<String> propertyNames) {
-        Map<String, Map<String, String>> operationsMap = new HashMap<>();
+    private List<CircuitBreakerClassConfiguration> readClasses(Collection<String> propertyNames) {
+        List<String> filteredPropertyNames = filterPropertyNames(propertyNames).stream()
+                .filter(property -> nameToValuePropertyMapper.apply(property).equals("true"))
+                .collect(Collectors.toList());
 
-        for (String propertyName : filterPropertyNames(propertyNames)) {
-            String operationName = getOperationName(propertyName);
-            String circuitBreakerAttributeName = getCircuitBreakerAttributeName(propertyName);
-            String circuitBreakerAttributeValue = nameToValuePropertyMapper.apply(propertyName).trim();
+        Set<String> classNames = filteredPropertyNames.stream()
+                .map(this::getClassName)
+                .collect(Collectors.toSet());
 
-            operationsMap.computeIfAbsent(operationName, k -> new HashMap<>())
-                    .put(circuitBreakerAttributeName, circuitBreakerAttributeValue);
-        }
+        return classNames.stream()
+                .map(className -> new CircuitBreakerClassConfiguration(className,
+                        getMethodNames(className, filteredPropertyNames)))
+                .collect(Collectors.toUnmodifiableList());
+    }
 
-        return operationsMap.entrySet().stream()
-                .map(entry -> new CircuitBreakerConfiguration.Operation(entry.getKey(), entry.getValue()))
+    private List<String> getMethodNames(String className, List<String> propertyNames) {
+        return propertyNames.stream()
+                .filter(propertyName -> propertyName.startsWith(className + "/"))
+                .map(this::getMethodName)
                 .collect(Collectors.toUnmodifiableList());
     }
 
-    private String getCircuitBreakerAttributeName(String propertyName) {
-        return propertyName.substring(propertyName.lastIndexOf("/") + 1);
+    private String getClassName(String propertyName) {
+        return propertyName.substring(0, propertyName.indexOf("/"));
     }
 
-    private String getOperationName(String propertyName) {
-        return propertyName.substring(operationIndex, propertyName.indexOf("/CircuitBreaker/"));
+    private String getMethodName(String propertyName) {
+        return propertyName.substring(propertyName.indexOf("/") + 1, propertyName.indexOf("/CircuitBreaker/"));
     }
 
     private List<String> filterPropertyNames(Collection<String> propertyNames) {
         return propertyNames.stream()
-                .filter(propertyName -> propertyName.matches(PROPERTY_REGEX))
                 .filter(propertyName -> propertyName
-                        .matches(CONFIG_PREFIX + "\"" + openApiFileName + "\"/.+/CircuitBreaker/.+"))
+                        .matches(".+/.+/CircuitBreaker/enabled"))
                 .collect(Collectors.toList());
     }
 }

deployment/src/main/java/io/quarkiverse/openapi/generator/deployment/codegen/OpenApiGeneratorCodeGenBase.java

@@ -48,9 +48,8 @@ public boolean trigger(CodeGenContext context) throws CodeGenException {
                         .filter(s -> s.endsWith(this.inputExtension()))
                         .map(Path::of).forEach(openApiFilePath -> {
                             final CircuitBreakerConfiguration circuitBreakerConfiguration = getCircuitBreakerConfiguration(
-                                    context,
-                                    openApiFilePath);
-                            
+                                    context);
+
                             final OpenApiClientGeneratorWrapper generator = new OpenApiClientGeneratorWrapper(
                                     openApiFilePath.normalize(), outDir)
                                             .withCircuitBreakerConfiguration(circuitBreakerConfiguration);
@@ -69,11 +68,11 @@ public boolean trigger(CodeGenContext context) throws CodeGenException {
         return false;
     }
 
-    private CircuitBreakerConfiguration getCircuitBreakerConfiguration(CodeGenContext context, Path openApiFilePath) {
+    private CircuitBreakerConfiguration getCircuitBreakerConfiguration(CodeGenContext context) {
         UnaryOperator<String> nameToValuePropertyMapper = propertyName -> context.config().getValue(propertyName,
                 String.class);
 
-        return new CircuitBreakerConfigurationParser(openApiFilePath.toFile().getName(), nameToValuePropertyMapper)
+        return new CircuitBreakerConfigurationParser(nameToValuePropertyMapper)
                 .parse(getConfigPropertyNames(context));
     }
 

deployment/src/main/resources/templates/api.qute

@@ -53,9 +53,11 @@ public interface {classname} {
     {#if op.hasProduces}
     @Produces(\{{#for produce in op.produces}"{produce.mediaType}"{#if produce_hasNext}, {/if}{/for}\})
     {/if}
-    {#if circuit-breaker.enabled}{#for cbOperationConfig in circuit-breaker.operations}{#if cbOperationConfig.name == op.nickname}
-    @org.eclipse.microprofile.faulttolerance.CircuitBreaker({cbOperationConfig.attributesAsString})
-    {/if}{/for}{/if}
+    {#for cbClassConfig in circuit-breaker.classConfigurations.orEmpty}{#if cbClassConfig.className == package + classname}
+    {#for cbMethod in cbClassConfig.methods.orEmpty}{#if cbMethod == op.nickname}
+    @org.eclipse.microprofile.faulttolerance.CircuitBreaker
+    {/if}{/for}
+    {/if}{/for}
     public {#if op.returnType}{op.returnType}{#else}void{/if} {op.nickname}({#for p in op.allParams}{#include pathParams.qute param=p/}{#include queryParams.qute param=p/}{#include bodyParams.qute param=p/}{#include formParams.qute param=p/}{#include headerParams.qute param=p/}{#if p_hasNext}, {/if}{/for});
 
     {/for}