Merge pull request #20 from hbelmiro/KOGITO-6685

Added Circuit Breaker feature

Author: ricardozanini

README.md

@@ -152,6 +152,122 @@ Similarly to bearer token, the API Key Authentication also has the token entry k
 
 The API Key scheme has an additional property that requires where to add the API key in the request token: header, cookie or query. The inner provider takes care of that for you. 
 
+## Circuit Breaker
+
+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
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Simple API",
+    "version": "1.0.0-SNAPSHOT"
+  },
+  "paths": {
+    "/hello": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/bye": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+````
+
+And you want to configure Circuit Breaker for the `/bye` endpoint, you can do it in the following way:
+
+Add the [SmallRye Fault Tolerance extension](https://quarkus.io/guides/smallrye-fault-tolerance) to your project's `pom.xml` file:
+
+````xml
+<dependency>
+    <groupId>io.quarkus</groupId>
+    <artifactId>quarkus-smallrye-fault-tolerance</artifactId>
+</dependency>
+````
+
+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.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
+    public String byeGet();
+
+    @GET
+    @Path("/hello")
+    @Produces({"text/plain"})
+    public String helloGet();
+
+}
+````
+
+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/pom.xml

@@ -97,6 +97,13 @@
     </dependency>
 
     <!-- Tests -->
+    <dependency>
+      <groupId>io.quarkiverse.openapi.generator</groupId>
+      <artifactId>quarkus-openapi-generator-test-utils</artifactId>
+      <version>${project.version}</version>
+      <scope>test</scope>
+    </dependency>
+
     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-junit5-internal</artifactId>

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

@@ -0,0 +1,55 @@
+package io.quarkiverse.openapi.generator.deployment.circuitbreaker;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import org.eclipse.microprofile.config.Config;
+
+public final class CircuitBreakerConfigurationParser {
+
+    private CircuitBreakerConfigurationParser() {
+    }
+
+    /**
+     * Parses the {@link Config} and returns a {@link Map} of class names and their methods that should be configured with
+     * circuit breaker.
+     *
+     * @return a {@link Map} of class names and their methods that should be configured with circuit breaker
+     */
+    public static Map<String, List<String>> parse(Config config) {
+        List<String> filteredPropertyNames = filterPropertyNames(config.getPropertyNames()).stream()
+                .filter(property -> config.getOptionalValue(property, Boolean.class).orElse(false))
+                .collect(Collectors.toList());
+
+        return filteredPropertyNames.stream()
+                .map(CircuitBreakerConfigurationParser::getClassName)
+                .distinct()
+                .collect(Collectors.toUnmodifiableMap(
+                        Function.identity(),
+                        className -> getMethodNames(className, filteredPropertyNames)));
+    }
+
+    private static List<String> getMethodNames(String className, List<String> propertyNames) {
+        return propertyNames.stream()
+                .filter(propertyName -> propertyName.startsWith(className + "/"))
+                .map(CircuitBreakerConfigurationParser::getMethodName)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private static String getClassName(String propertyName) {
+        return propertyName.substring(0, propertyName.indexOf("/"));
+    }
+
+    private static String getMethodName(String propertyName) {
+        return propertyName.substring(propertyName.indexOf("/") + 1, propertyName.indexOf("/CircuitBreaker/"));
+    }
+
+    private static List<String> filterPropertyNames(Iterable<String> propertyNames) {
+        return StreamSupport.stream(propertyNames.spliterator(), false)
+                .filter(propertyName -> propertyName.matches(".+/.+/CircuitBreaker/enabled"))
+                .collect(Collectors.toList());
+    }
+}

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

@@ -7,6 +7,7 @@
 import java.nio.file.Path;
 import java.util.stream.Stream;
 
+import io.quarkiverse.openapi.generator.deployment.circuitbreaker.CircuitBreakerConfigurationParser;
 import io.quarkiverse.openapi.generator.deployment.wrapper.OpenApiClientGeneratorWrapper;
 import io.quarkus.bootstrap.prebuild.CodeGenException;
 import io.quarkus.deployment.CodeGenContext;
@@ -42,7 +43,10 @@ public boolean trigger(CodeGenContext context) throws CodeGenException {
                         .filter(s -> s.endsWith(this.inputExtension()))
                         .map(Path::of).forEach(openApiFilePath -> {
                             final OpenApiClientGeneratorWrapper generator = new OpenApiClientGeneratorWrapper(
-                                    openApiFilePath.normalize(), outDir);
+                                    openApiFilePath.normalize(), outDir)
+                                            .withCircuitBreakerConfiguration(CircuitBreakerConfigurationParser.parse(
+                                                    context.config()));
+
                             context.config()
                                     .getOptionalValue(getResolvedBasePackageProperty(openApiFilePath), String.class)
                                     .ifPresent(generator::withBasePackage);

deployment/src/main/java/io/quarkiverse/openapi/generator/deployment/wrapper/OpenApiClientGeneratorWrapper.java

@@ -6,6 +6,7 @@
 import java.io.File;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Map;
 
 import org.openapitools.codegen.CodegenConstants;
 import org.openapitools.codegen.DefaultGenerator;
@@ -68,6 +69,17 @@ public OpenApiClientGeneratorWrapper withBasePackage(final String pkg) {
         return this;
     }
 
+    /**
+     * Adds the circuit breaker configuration to the generator.
+     *
+     * @param config a map of class names and their methods that should be configured with circuit breaker
+     * @return this wrapper
+     */
+    public OpenApiClientGeneratorWrapper withCircuitBreakerConfiguration(final Map<String, List<String>> config) {
+        configurator.addAdditionalProperty("circuit-breaker", config);
+        return this;
+    }
+
     public List<File> generate() {
         this.consolidatePackageNames();
         return generator.opts(configurator.toClientOptInput()).generate();

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

@@ -53,6 +53,11 @@ public interface {classname} {
     {#if op.hasProduces}
     @Produces(\{{#for produce in op.produces}"{produce.mediaType}"{#if produce_hasNext}, {/if}{/for}\})
     {/if}
+    {#for cbClassConfig in circuit-breaker.orEmpty}{#if cbClassConfig.key == package + classname}
+    {#for cbMethod in cbClassConfig.value.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}

deployment/src/test/java/io/quarkiverse/openapi/generator/deployment/assertions/Assertions.java

@@ -0,0 +1,15 @@
+package io.quarkiverse.openapi.generator.deployment.assertions;
+
+import com.github.javaparser.ast.body.MethodDeclaration;
+
+import io.quarkiverse.openapi.generator.testutils.circuitbreaker.assertions.CircuitBreakerMethodAssert;
+
+public final class Assertions extends org.assertj.core.api.Assertions {
+
+    private Assertions() {
+    }
+
+    public static CircuitBreakerMethodAssert assertThat(MethodDeclaration actual) {
+        return CircuitBreakerMethodAssert.assertThat(actual);
+    }
+}

deployment/src/test/java/io/quarkiverse/openapi/generator/deployment/circuitbreaker/CircuitBreakerConfigurationParserTest.java

@@ -0,0 +1,69 @@
+package io.quarkiverse.openapi.generator.deployment.circuitbreaker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
+import org.junit.jupiter.api.Test;
+
+import io.smallrye.config.PropertiesConfigSource;
+
+class CircuitBreakerConfigurationParserTest {
+
+    @Test
+    void parse() {
+        Config config = mockConfig("/circuitbreaker/application.properties");
+
+        Map<String, List<String>> circuitBreakerConfiguration = CircuitBreakerConfigurationParser.parse(config);
+
+        assertThat(circuitBreakerConfiguration.get("org.acme.CountryResource"))
+                .containsExactlyInAnyOrder("getCountries", "getByCapital");
+
+        assertThat(circuitBreakerConfiguration.get("org.acme.CityResource"))
+                .containsOnly("get");
+    }
+
+    @Test
+    void circuitBreakerDisabledShouldReturnEmptyConfig() {
+        Config config = mockConfig("/circuitbreaker/circuit_breaker_disabled_application.properties");
+
+        Map<String, List<String>> circuitBreakerConfiguration = CircuitBreakerConfigurationParser.parse(config);
+
+        assertThat(circuitBreakerConfiguration).isEmpty();
+    }
+
+    @Test
+    void missingCircuitBreakerEnabledConfigShouldReturnEmptyConfig() {
+        Config config = mockConfig("/circuitbreaker/missing_circuit_breaker_enabled_application.properties");
+
+        Map<String, List<String>> circuitBreakerConfiguration = CircuitBreakerConfigurationParser.parse(config);
+
+        assertThat(circuitBreakerConfiguration).isEmpty();
+    }
+
+    private static Config mockConfig(String propertiesFile) {
+        PropertiesConfigSource configSource;
+        try {
+            configSource = new PropertiesConfigSource(getResource(propertiesFile));
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+
+        return ConfigProviderResolver
+                .instance()
+                .getBuilder()
+                .withSources(configSource)
+                .build();
+    }
+
+    private static URL getResource(String resourcePath) {
+        return Objects.requireNonNull(CircuitBreakerConfigurationParserTest.class.getResource(resourcePath));
+    }
+}