Rename annotations (#239). Removed dedicated reader classes to ease d…

…eprecation handling

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/AbstractZeebeBaseClientSpringConfiguration.java

@@ -5,7 +5,6 @@
 import io.camunda.zeebe.client.api.worker.BackoffSupplier;
 import io.camunda.zeebe.client.impl.worker.ExponentialBackoffBuilderImpl;
 import io.camunda.zeebe.spring.client.annotation.processor.AnnotationProcessorConfiguration;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadAnnotationValueConfiguration;
 import io.camunda.zeebe.spring.client.jobhandling.DefaultCommandExceptionHandlingStrategy;
 import io.camunda.zeebe.spring.client.jobhandling.JobWorkerManager;
 import io.camunda.zeebe.spring.client.jobhandling.SpringSecretProvider;
@@ -23,8 +22,7 @@
  * The subclasses add the differences for prod/test
  */
 @Import({
-  AnnotationProcessorConfiguration.class,
-  ReadAnnotationValueConfiguration.class,
+  AnnotationProcessorConfiguration.class
 })
 public abstract class AbstractZeebeBaseClientSpringConfiguration {
 

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/CustomHeaders.java

@@ -0,0 +1,8 @@
+package io.camunda.zeebe.spring.client.annotation;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface CustomHeaders {}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/Deployment.java

@@ -0,0 +1,12 @@
+package io.camunda.zeebe.spring.client.annotation;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited // has to be inherited to work on spring aop beans
+public @interface Deployment {
+
+  String[] resources() default {};
+}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/JobWorker.java

@@ -0,0 +1,39 @@
+package io.camunda.zeebe.spring.client.annotation;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface JobWorker {
+
+  String type() default ""; // set to empty string which leads to method name being used (if not ${zeebe.client.worker.default-type}" is configured) Implemented in ZeebeWorkerAnnotationProcessor
+
+  String name() default ""; // set to empty string which leads to default from ZeebeClientBuilderImpl being used in ZeebeWorkerAnnotationProcessor
+
+  long timeout() default -1L;
+
+  int maxJobsActive() default -1;
+
+  long requestTimeout() default -1L;
+
+  long pollInterval() default -1L;
+
+  String[] fetchVariables() default {};
+
+  /**
+   * If set to true, all variables are fetched
+   */
+  boolean fetchAllVariables() default false;
+
+  /**
+   * If set to true, the job is automatically completed after the worker code has finished.
+   * In this case, your worker code is not allowed to complete the job itself.
+   *
+   *  You can still throw exceptions if you want to raise a problem instead of job completion.
+   *  You could also raise a BPMN problem throwing a {@link io.camunda.zeebe.spring.client.exception.ZeebeBpmnError}
+   */
+  boolean autoComplete() default true;
+
+  boolean enabled() default true;
+}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/Variable.java

@@ -0,0 +1,10 @@
+package io.camunda.zeebe.spring.client.annotation;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Variable {
+
+}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/VariablesAsType.java

@@ -0,0 +1,8 @@
+package io.camunda.zeebe.spring.client.annotation;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface VariablesAsType {}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/ZeebeCustomHeaders.java

@@ -5,4 +5,9 @@
 @Target(ElementType.PARAMETER)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+/**
+ * @deprecated
+ * Use {@link CustomHeaders} instead.
+ */
+@Deprecated
 public @interface ZeebeCustomHeaders {}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/ZeebeDeployment.java

@@ -11,6 +11,11 @@
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited // has to be inherited to work on spring aop beans
+/**
+ * @deprecated
+ * Use {@link Deployment} instead.
+ */
+@Deprecated
 public @interface ZeebeDeployment {
 
   @Deprecated

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/ZeebeVariable.java

@@ -5,6 +5,11 @@
 @Target(ElementType.PARAMETER)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+/**
+ * @deprecated
+ * Use {@link Variable} instead.
+ */
+@Deprecated
 public @interface ZeebeVariable {
 
 }

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/ZeebeVariablesAsType.java

@@ -5,4 +5,9 @@
 @Target(ElementType.PARAMETER)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+/**
+ * @deprecated
+ * Use {@link VariablesAsType} instead.
+ */
+@Deprecated
 public @interface ZeebeVariablesAsType {}

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/ZeebeWorker.java

@@ -9,6 +9,11 @@
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+/**
+ * @deprecated
+ * Use {@link JobWorker} instead. Note, that the default for auto completion has changed there from "false" to "true"!
+ */
+@Deprecated
 public @interface ZeebeWorker {
 
   String type() default ""; // set to empty string which leads to method name being used (if not ${zeebe.client.worker.default-type}" is configured) Implemented in ZeebeWorkerAnnotationProcessor

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/processor/AnnotationProcessorConfiguration.java

@@ -1,20 +1,12 @@
 package io.camunda.zeebe.spring.client.annotation.processor;
 
-import io.camunda.connector.api.annotation.OutboundConnector;
-import io.camunda.zeebe.client.api.worker.BackoffSupplier;
 import io.camunda.zeebe.spring.client.annotation.customizer.ZeebeWorkerValueCustomizer;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadAnnotationValueConfiguration;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadOutboundConnectorValue;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadZeebeDeploymentValue;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadZeebeWorkerValue;
-import java.util.List;
-
-import io.camunda.zeebe.spring.client.jobhandling.DefaultCommandExceptionHandlingStrategy;
 import io.camunda.zeebe.spring.client.jobhandling.JobWorkerManager;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Import;
+import org.springframework.core.env.Environment;
+
+import java.util.List;
 
-@Import(ReadAnnotationValueConfiguration.class)
 public class AnnotationProcessorConfiguration {
 
   @Bean
@@ -23,20 +15,22 @@ public ZeebeAnnotationProcessorRegistry zeebeAnnotationProcessorRegistry(final L
   }
 
   @Bean
-  public ZeebeDeploymentAnnotationProcessor deploymentPostProcessor(final ReadZeebeDeploymentValue reader) {
-    return new ZeebeDeploymentAnnotationProcessor(reader);
+  public ZeebeDeploymentAnnotationProcessor deploymentPostProcessor() {
+    return new ZeebeDeploymentAnnotationProcessor();
   }
 
   @Bean
-  public OutboundConnectorAnnotationProcessor outboundConnectorAnnotationProcessor(final ReadOutboundConnectorValue reader, final JobWorkerManager jobWorkerManager) {
-    return new OutboundConnectorAnnotationProcessor(reader, jobWorkerManager);
+  public OutboundConnectorAnnotationProcessor outboundConnectorAnnotationProcessor(final JobWorkerManager jobWorkerManager) {
+    return new OutboundConnectorAnnotationProcessor(jobWorkerManager);
   }
 
   @Bean
-  public ZeebeWorkerAnnotationProcessor zeebeWorkerPostProcessor(final ReadZeebeWorkerValue reader,
-                                                                 final JobWorkerManager jobWorkerManager,
-                                                                 final List<ZeebeWorkerValueCustomizer> zeebeWorkerValueCustomizers) {
-    return new ZeebeWorkerAnnotationProcessor(reader, jobWorkerManager, zeebeWorkerValueCustomizers);
+  public ZeebeWorkerAnnotationProcessor zeebeWorkerPostProcessor(final JobWorkerManager jobWorkerManager,
+                                                                 final List<ZeebeWorkerValueCustomizer> zeebeWorkerValueCustomizers,
+                                                                 final Environment environment) { // can#t use @Value because it is only evaluated after constructors are executed
+    String defaultWorkerType = environment.getProperty("zeebe.client.worker.default-type", (String)null);
+    String defaultJobWorkerName = environment.getProperty("zeebe.client.worker.default-name", (String)null);
+    return new ZeebeWorkerAnnotationProcessor(jobWorkerManager, zeebeWorkerValueCustomizers, defaultWorkerType, defaultJobWorkerName);
   }
 
 }

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/processor/OutboundConnectorAnnotationProcessor.java

@@ -4,20 +4,13 @@
 import io.camunda.connector.api.outbound.OutboundConnectorFunction;
 import io.camunda.zeebe.client.ZeebeClient;
 import io.camunda.zeebe.client.api.worker.JobWorker;
-import io.camunda.zeebe.spring.client.annotation.ZeebeWorker;
 import io.camunda.zeebe.spring.client.annotation.value.OutboundConnectorValue;
 import io.camunda.zeebe.spring.client.annotation.value.ZeebeWorkerValue;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadOutboundConnectorValue;
 import io.camunda.zeebe.spring.client.bean.ClassInfo;
-import io.camunda.zeebe.spring.client.bean.MethodInfo;
 import io.camunda.zeebe.spring.client.jobhandling.JobWorkerManager;
-import io.camunda.zeebe.spring.client.jobhandling.copy.OutboundConnectorFunctionInvoker;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.core.io.Resource;
-import org.springframework.util.ReflectionUtils;
 
-import java.io.IOException;
 import java.lang.invoke.MethodHandles;
 import java.util.ArrayList;
 import java.util.List;
@@ -30,12 +23,11 @@
 public class OutboundConnectorAnnotationProcessor extends AbstractZeebeAnnotationProcessor {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
-  private ReadOutboundConnectorValue reader;
+
   private final List<OutboundConnectorValue> outboundConnectors = new ArrayList<>();
   private final JobWorkerManager jobWorkerManager;
 
-  public OutboundConnectorAnnotationProcessor(ReadOutboundConnectorValue reader,  final JobWorkerManager jobWorkerManager) {
-    this.reader = reader;
+  public OutboundConnectorAnnotationProcessor(final JobWorkerManager jobWorkerManager) {
     this.jobWorkerManager = jobWorkerManager;
   }
 
@@ -46,9 +38,14 @@ public boolean isApplicableFor(ClassInfo beanInfo) {
 
   @Override
   public void configureFor(ClassInfo beanInfo) {
-    Optional<OutboundConnectorValue> connectorValue = reader.apply(beanInfo);
-    if (connectorValue.isPresent()) {
-      OutboundConnectorValue connector = connectorValue.get();
+    Optional<OutboundConnector> annotation = beanInfo.getAnnotation(OutboundConnector.class);
+    if (annotation.isPresent()) {
+      OutboundConnectorValue connector = new OutboundConnectorValue()
+            .setBeanInfo(beanInfo)
+            .setType(annotation.get().type())
+            .setName(annotation.get().name())
+            .setInputVariables(annotation.get().inputVariables());
+
       LOGGER.info("Configuring outbound connector {} of bean '{}'", connector, beanInfo.getBeanName());
       outboundConnectors.add(connector);
     }

client/spring-zeebe/src/main/java/io/camunda/zeebe/spring/client/annotation/processor/ZeebeDeploymentAnnotationProcessor.java

@@ -3,10 +3,11 @@
 import io.camunda.zeebe.client.ZeebeClient;
 import io.camunda.zeebe.client.api.command.DeployResourceCommandStep1;
 import io.camunda.zeebe.client.api.response.DeploymentEvent;
+import io.camunda.zeebe.spring.client.annotation.Deployment;
 import io.camunda.zeebe.spring.client.annotation.ZeebeDeployment;
+import io.camunda.zeebe.spring.client.bean.BeanInfo;
 import io.camunda.zeebe.spring.client.bean.ClassInfo;
 import io.camunda.zeebe.spring.client.annotation.value.ZeebeDeploymentValue;
-import io.camunda.zeebe.spring.client.annotation.value.factory.ReadZeebeDeploymentValue;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.core.io.Resource;
@@ -16,16 +17,14 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.invoke.MethodHandles;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
  * Always created by {@link AnnotationProcessorConfiguration}
  *
- * Loop throgh @{@link ZeebeDeployment} annotations to deploy resources to Zeebe
+ * Loop throgh @{@link Deployment} annotations to deploy resources to Zeebe
  * once the {@link io.camunda.zeebe.spring.client.lifecycle.ZeebeClientLifecycle} was initialized.
  */
 public class ZeebeDeploymentAnnotationProcessor extends AbstractZeebeAnnotationProcessor {
@@ -34,25 +33,66 @@ public class ZeebeDeploymentAnnotationProcessor extends AbstractZeebeAnnotationP
 
   private static final ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
 
-  private final ReadZeebeDeploymentValue reader;
-
   private List<ZeebeDeploymentValue> deploymentValues = new ArrayList<>();
 
-  public ZeebeDeploymentAnnotationProcessor(ReadZeebeDeploymentValue reader) {
-    this.reader = reader;
+  public ZeebeDeploymentAnnotationProcessor() {
   }
 
   @Override
   public boolean isApplicableFor(ClassInfo beanInfo) {
-    return beanInfo.hasClassAnnotation(ZeebeDeployment.class);
+    return beanInfo.hasClassAnnotation(Deployment.class) || beanInfo.hasClassAnnotation(ZeebeDeployment.class);
   }
 
   @Override
   public void configureFor(final ClassInfo beanInfo) {
-    ZeebeDeploymentValue value = reader.applyOrThrow(beanInfo);
-    LOGGER.info("Configuring deployment: {}", value);
+    Optional<ZeebeDeploymentValue> zeebeDeploymentValue = readAnnotation(beanInfo);
+    if (zeebeDeploymentValue.isPresent()) {
+      LOGGER.info("Configuring deployment: {}", zeebeDeploymentValue.get());
+      deploymentValues.add(zeebeDeploymentValue.get());
+    }
+  }
+
+  public Optional<ZeebeDeploymentValue> readAnnotation(ClassInfo beanInfo) {
+    Optional<Deployment> annotation = beanInfo.getAnnotation(Deployment.class);
+    if (!annotation.isPresent()) {
+      return readDeprecatedAnnotation(beanInfo);
+    } else {
+      List<String> resources = Arrays.stream(annotation.get().resources()).collect(Collectors.toList());
+      return Optional.of(ZeebeDeploymentValue.builder()
+        .beanInfo(beanInfo)
+        .resources(resources)
+        .build());
+    }
+  }
+
+  private static final String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
+
+  /**
+   * Seperate handling for legacy annotation (had additional classPathResources attribute)
+   * @param beanInfo
+   */
+  private Optional<ZeebeDeploymentValue> readDeprecatedAnnotation(ClassInfo beanInfo) {
+    Optional<ZeebeDeployment> annotation = beanInfo.getAnnotation(ZeebeDeployment.class);
+    if (!annotation.isPresent()) {
+      return Optional.empty();
+    }
+
+    List<String> resources = Arrays.stream(annotation.get().resources()).collect(Collectors.toList());
+
+    String[] classPathResources = annotation.get().classPathResources();
+    if (classPathResources.length > 0) {
+      resources.addAll(
+        Arrays.stream(classPathResources)
+          .map(resource -> CLASSPATH_ALL_URL_PREFIX + resource)
+          .collect(Collectors.toList())
+      );
+    }
 
-    deploymentValues.add(value);
+    return Optional.of(
+      ZeebeDeploymentValue.builder()
+        .beanInfo(beanInfo)
+        .resources(resources)
+        .build());
   }
 
   @Override