Updates to conform with adapter xml

interlok-core/src/main/java/com/adaptris/core/ConfigurableEventHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 Adaptris Ltd.
+ * Copyright 2024 Adaptris Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,25 +19,17 @@
 import com.adaptris.annotation.AdapterComponent;
 import com.adaptris.annotation.AutoPopulated;
 import com.adaptris.annotation.ComponentProfile;
-import com.adaptris.annotation.InputFieldDefault;
-import com.adaptris.annotation.InputFieldHint;
-import com.adaptris.core.util.Args;
-import com.adaptris.core.util.LifecycleHelper;
 import com.thoughtworks.xstream.annotations.XStreamAlias;
 import com.thoughtworks.xstream.annotations.XStreamImplicit;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.Setter;
 
 import javax.validation.Valid;
-import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.NotNull;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /**
  * <p>
@@ -52,14 +44,15 @@
  */
 @XStreamAlias("configurable-event-handler")
 @AdapterComponent
-@ComponentProfile(summary = "Sends MessageLifecycleEvents to a destination based on the matching rule, or default if no match", tag = "base,events")
+@ComponentProfile(summary = "Sends Events to a destination based on the matching rule, or default if no match", tag = "base,events")
 public class ConfigurableEventHandler extends DefaultEventHandler {
 
   @Valid
   @NotNull
   @AutoPopulated
   @XStreamImplicit
   @Getter
+  @Setter
   private List<Rule> rules;
 
   public ConfigurableEventHandler() {
@@ -82,8 +75,8 @@ public ConfigurableEventHandler(AdaptrisConnection connection, AdaptrisMessagePr
    */
   protected AdaptrisMessageSender resolveEventSender(Event event) {
     for (Rule rule : rules) {
-      if (rule.matcher.matches(event)) {
-        return rule.standaloneProducer;
+      if (rule.getMatcher() != null && rule.getMatcher().matches(event)) {
+        return rule.getStandaloneProducer();
       }
     }
     return getProducer();
@@ -100,7 +93,7 @@ public void send(Event evt, Map<String, String> properties) throws CoreException
   protected void eventHandlerInit() throws CoreException {
     super.eventHandlerInit();
     for(Rule rule : rules) {
-      rule.standaloneProducer.init();
+      if (rule.getStandaloneProducer() != null) rule.getStandaloneProducer().init();
     }
   }
 
@@ -109,7 +102,7 @@ protected void eventHandlerInit() throws CoreException {
   protected void eventHandlerStart() throws CoreException {
     super.eventHandlerStart();
     for(Rule rule : rules) {
-      rule.standaloneProducer.start();
+      if (rule.getStandaloneProducer() != null) rule.getStandaloneProducer().start();
     }
   }
 
@@ -118,7 +111,7 @@ protected void eventHandlerStart() throws CoreException {
   protected void eventHandlerStop() {
     super.eventHandlerStop();
     for(Rule rule : rules) {
-      rule.standaloneProducer.stop();
+      if (rule.getStandaloneProducer() != null) rule.getStandaloneProducer().stop();
     }
   }
 
@@ -127,76 +120,48 @@ protected void eventHandlerStop() {
   protected void eventHandlerClose() {
     super.eventHandlerClose();
     for(Rule rule : rules) {
-      rule.standaloneProducer.close();
+      if (rule.getStandaloneProducer() != null) rule.getStandaloneProducer().close();
     }
   }
 
   @Override
   public void prepare() throws CoreException {
     super.prepare();
     for(Rule rule : rules) {
-      rule.standaloneProducer.prepare();
+      if (rule.getStandaloneProducer() != null) rule.getStandaloneProducer().prepare();
     }
   }
 
 
-  /**
-   * Matches on an event
-   */
-  interface EventMatcher {
-    enum MatchType {
-      SOURCE_ID(event -> event.getSourceId()),
-      DESTINATION_ID(event -> event.getDestinationId()),
-      NAMESPACE(event -> event.getNameSpace()),
-      TYPE(event -> event.getClass().getCanonicalName());
-
-      Function<Event, Object> getter;
-      MatchType(Function<Event, Object> getter) {
-        this.getter = getter;
-      }
+  @AllArgsConstructor
+  @AdapterComponent
+  @XStreamAlias("rule")
+  @ComponentProfile(summary = "Combination of a matcher to match events and a standalone producer for the destination", tag = "events")
+  public static class Rule {
 
-      public Object getProperty(Event event) {
-        return getter.apply(event);
+      private EventMatcher matcher;
+
+      private StandaloneProducer standaloneProducer;
+
+      public Rule() {
+          matcher = new NullEventMatcher();
+          standaloneProducer = new StandaloneProducer();
       }
-    }
 
-    boolean matches(Event event);
-  }
+      public EventMatcher getMatcher() {
+          return matcher;
+      }
 
-  /**
-   * Matches based on supplied regex
-   */
-  @XStreamAlias("regex-event-matcher")
-  static class RegexEventMatcher implements EventMatcher {
-    @NotNull
-    @NotBlank
-    private String regex;
-    @NotNull
-    private Set<MatchType> matchTypes;
-
-    private transient Pattern compiledRegex;
-
-    public RegexEventMatcher(String regex, Set<MatchType> matchTypes) {
-      this.regex = regex;
-      this.matchTypes = matchTypes;
-      this.compiledRegex = Pattern.compile(regex);
-    }
+      public void setMatcher(EventMatcher matcher) {
+          this.matcher = matcher;
+      }
 
-    @Override
-    public boolean matches(Event event) {
-      for (MatchType matchType : matchTypes) {
-        if (compiledRegex.matcher((String)matchType.getProperty(event)).matches()) return true;
+      public StandaloneProducer getStandaloneProducer() {
+          return standaloneProducer;
       }
-      return false;
-    }
-  }
 
-  @XStreamAlias("rule")
-  @AllArgsConstructor
-  static class Rule {
-    @NotNull
-    private EventMatcher matcher;
-    @NotNull
-    private StandaloneProducer standaloneProducer;
+      public void setStandaloneProducer(StandaloneProducer standaloneProducer) {
+          this.standaloneProducer = standaloneProducer;
+      }
   }
 }

interlok-core/src/main/java/com/adaptris/core/EventMatcher.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2024 Adaptris Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.adaptris.core;
+
+import java.util.function.Function;
+
+/**
+ * Matches on an event
+ */
+public interface EventMatcher {
+
+    boolean matches(Event event);
+
+    enum EventMatchType {
+        SOURCE_ID(event -> event.getSourceId()),
+        DESTINATION_ID(event -> event.getDestinationId()),
+        NAMESPACE(event -> event.getNameSpace()),
+        TYPE(event -> event.getClass().getCanonicalName());
+
+        Function<Event, Object> getter;
+
+        EventMatchType(Function<Event, Object> getter) {
+            this.getter = getter;
+        }
+
+        public Object getProperty(Event event) {
+            return getter.apply(event);
+        }
+    }
+}

interlok-core/src/main/java/com/adaptris/core/NullEventMatcher.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Adaptris Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.adaptris.core;
+
+import com.adaptris.annotation.AdapterComponent;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+
+/**
+ * Matches based on supplied regex
+ */
+@XStreamAlias("null-event-matcher")
+@AdapterComponent
+public class NullEventMatcher implements EventMatcher {
+
+    public NullEventMatcher() {
+    }
+
+    @Override
+    public boolean matches(Event event) {
+        return false;
+    }
+}

interlok-core/src/main/java/com/adaptris/core/RegexEventMatcher.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2024 Adaptris Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.adaptris.core;
+
+import com.adaptris.annotation.AdapterComponent;
+import com.adaptris.annotation.ComponentProfile;
+import com.thoughtworks.xstream.annotations.XStreamAlias;
+import com.thoughtworks.xstream.annotations.XStreamImplicit;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Matches based on supplied regex
+ */
+@XStreamAlias("regex-event-matcher")
+@AdapterComponent
+@ComponentProfile(summary = "A matcher that uses regex to match on an event's properties", tag = "events")
+public class RegexEventMatcher implements EventMatcher {
+
+
+    private String regex;
+
+    @XStreamImplicit(itemFieldName = "match-type")
+    private Set<String> matchTypes;
+
+    private transient Set<EventMatchType> matchTypeEnumSet;
+
+    private transient Pattern compiledRegex;
+
+    public RegexEventMatcher() {
+        setRegex("");
+        setMatchTypes(new LinkedHashSet<>());
+    }
+
+    public RegexEventMatcher(String regex, Set<String> matchTypes) {
+        setMatchTypes(matchTypes);
+        setRegex(regex);
+    }
+
+    public void setRegex(String regex) {
+        this.regex = regex;
+        this.compiledRegex = Pattern.compile(regex);
+    }
+
+    public String getRegex() {
+        return regex;
+    }
+
+    public Set<String> getMatchTypes() {
+        return matchTypes;
+    }
+
+    public void setMatchTypes(Set<String> matchTypes) {
+        this.matchTypeEnumSet = matchTypes.stream().map(EventMatchType::valueOf).collect(Collectors.toSet());
+        this.matchTypes = matchTypes;
+    }
+
+    @Override
+    public boolean matches(Event event) {
+        for (EventMatchType matchType : matchTypeEnumSet) {
+            if (compiledRegex.matcher((String) matchType.getProperty(event)).matches()) return true;
+        }
+        return false;
+    }
+}