Add tdjam-controller

the details is on wiki:

https://wiki.onap.org/display/DW/tdjam+Feature+for+Tosca-Driven+Control+Loops

Fixed some eclipse warnings.
Revised the interaction between a manager and its SerialWorkQueue to
address some threading issues.  The original code started processing
the event as soon as the manager was created, WHILE it was still being
added to the map.  During junit tests, the event responses came back,
within the same thread, which then attempted to remove the manager from
the map.  This resulted in a ConcurrentHashMap exception.

Issue-ID: POLICY-2415
Change-Id: I94a4152637be76e5b2aea2d869afd84dfb413a0e
Signed-off-by: Straubs, Ralph (rs8887) <rs8887@att.com>
Signed-off-by: jhh <jorge.hernandez-herrero@att.com>
Signed-off-by: Taka Cho <takamune.cho@att.com>
Signed-off-by: Jim Hahn <jrh3@att.com>

5 files changed, 1626 insertions, 0 deletions

diff --git a/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/SerialWorkQueue.java b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/SerialWorkQueue.java
new file mode 100644
index 000000000..7d83765a3
--- /dev/null
+++ b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/SerialWorkQueue.java
@@ -0,0 +1,123 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.tdjam;
+
+import java.util.LinkedList;
+import lombok.Getter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class provides a way to handle synchronization, with minimal blocking. Requests
+ * are queued until {@link #start()} is invoked.
+ */
+public class SerialWorkQueue {
+    private static Logger logger = LoggerFactory.getLogger(SerialWorkQueue.class);
+
+    // current work list
+    private LinkedList<Runnable> workQueue;
+
+    @Getter
+    private boolean running = false;
+
+    /**
+     * Constructor - no initial Runnable.
+     */
+    public SerialWorkQueue() {
+        workQueue = new LinkedList<>();
+    }
+
+    /**
+     * Constructor - initial 'Runnable' is specified.
+     *
+     * @param runnable an initial 'Runnnable' to run
+     */
+    public SerialWorkQueue(Runnable runnable) {
+        workQueue = new LinkedList<>();
+        workQueue.add(runnable);
+    }
+
+    /**
+     * Starts the queue. If the current thread is the first to start it, then the current
+     * thread will process any requests in the queue before returning.
+     */
+    public void start() {
+        Runnable item;
+
+        synchronized (this) {
+            if (running) {
+                // already running
+                return;
+            }
+
+            running = true;
+            item = workQueue.peekFirst();
+        }
+
+        if (item != null) {
+            processQueue(item);
+        }
+    }
+
+    /**
+     * Called to add a 'Runnable' to the work queue. If the queue was empty, the current
+     * thread is used to process the queue.
+     *
+     * @param work the Runnable to be queued, and eventually run
+     */
+    public void queueAndRun(Runnable work) {
+        synchronized (this) {
+            workQueue.add(work);
+            if (!running || workQueue.size() > 1) {
+                // there was already work in the queue, so presumably there is
+                // already an associated thread running
+                return;
+            }
+            // if we reach this point, the queue was empty when this method was
+            // called, so this thread will process the queue
+        }
+
+        processQueue(work);
+    }
+
+    /**
+     * Internal method to process the work queue until it is empty. Note that entries
+     * could be added by this thread or another one while we are working.
+     *
+     * @param firstItem the first item in the queue
+     */
+    private void processQueue(Runnable firstItem) {
+        Runnable next = firstItem;
+        while (next != null) {
+            try {
+                next.run();
+            } catch (Exception e) {
+                logger.error("SerialWorkQueue.processQueue exception", e);
+            }
+
+            synchronized (this) {
+                // remove the job we just ran
+                workQueue.removeFirst();
+                next = workQueue.peekFirst();
+            }
+        }
+    }
+}
diff --git a/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/TdjamController.java b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/TdjamController.java
new file mode 100644
index 000000000..0b17f196f
--- /dev/null
+++ b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/controlloop/tdjam/TdjamController.java
@@ -0,0 +1,833 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.tdjam;
+
+import static org.onap.policy.drools.properties.DroolsPropertyConstants.PROPERTY_CONTROLLER_TYPE;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import org.onap.policy.common.endpoints.event.comm.Topic;
+import org.onap.policy.common.endpoints.event.comm.TopicEndpointManager;
+import org.onap.policy.common.endpoints.event.comm.TopicListener;
+import org.onap.policy.common.endpoints.event.comm.TopicSource;
+import org.onap.policy.controlloop.CanonicalOnset;
+import org.onap.policy.controlloop.ControlLoopEvent;
+import org.onap.policy.controlloop.ControlLoopException;
+import org.onap.policy.controlloop.ControlLoopNotificationType;
+import org.onap.policy.controlloop.ControlLoopResponse;
+import org.onap.policy.controlloop.VirtualControlLoopEvent;
+import org.onap.policy.controlloop.VirtualControlLoopNotification;
+import org.onap.policy.controlloop.drl.legacy.ControlLoopParams;
+import org.onap.policy.controlloop.eventmanager.ControlLoopEventManager2;
+import org.onap.policy.controlloop.utils.ControlLoopUtils;
+import org.onap.policy.drools.controller.DroolsController;
+import org.onap.policy.drools.features.DroolsControllerFeatureApi;
+import org.onap.policy.drools.features.PolicyControllerFeatureApi;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoder.CoderFilters;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoderConstants;
+import org.onap.policy.drools.protocol.coders.ProtocolCoderToolset;
+import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration;
+import org.onap.policy.drools.system.PolicyController;
+import org.onap.policy.drools.system.PolicyEngineConstants;
+import org.onap.policy.extension.system.NonDroolsPolicyController;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This replaces a Drools session with Java code. Although Drools memory
+ * is simulated when running the Junit tests, there is no actual use of
+ * Drools here.
+ */
+public class TdjamController extends NonDroolsPolicyController {
+    private static Logger logger = LoggerFactory.getLogger(TdjamController.class);
+
+    // the 'controller.type' property is set to this value
+    private static final String TDJAM_CONTROLLER_BUILDER_TAG = "tdjam";
+
+    // additional data associated with session
+    private final String groupId;
+    private final String artifactId;
+
+    // top-level tosca policy table (first key = name, second key = version)
+    private final Map<String, Map<String, ToscaPolicy>> toscaPolicies = new HashMap<>();
+
+    // maps 'controlLoopControlName' to 'ControlLoopParams'
+    private final Map<String, ControlLoopParams> controlLoopParams = new HashMap<>();
+
+    // maps 'requestId' to 'ControlLoopEventManager'
+    private final Map<UUID, ControlLoopEventManager> eventManagers = new ConcurrentHashMap<>();
+
+    // maps onset to 'ControlLoopEventManager'
+    private final Map<VirtualControlLoopEvent, ControlLoopEventManager> onsetToEventManager = new ConcurrentHashMap<>();
+
+    // maps 'topic' to 'TopicData'
+    private final Map<String, TopicData> topicDataTable = new ConcurrentHashMap<>();
+
+    /* ============================================================ */
+
+    /**
+     * Initialize a new 'TdjamController'.
+     *
+     * @param name the controller name
+     * @param properties properties defining the controller
+     */
+    public TdjamController(String name, Properties properties) {
+        super(name, properties);
+
+        this.groupId = getGroupId();
+        this.artifactId = getArtifactId();
+
+        init();
+    }
+
+    private void init() {
+        // go through all of the incoming message decoders associated
+        // with this controller
+        for (ProtocolCoderToolset pct :
+                EventProtocolCoderConstants.getManager()
+                .getDecoders(groupId, artifactId)) {
+            // go through the 'CoderFilters' instances, and see if there are
+            // any that we are interested in
+            for (CoderFilters cf : pct.getCoders()) {
+                try {
+                    Class<?> clazz = Class.forName(cf.getCodedClass());
+                    if (ControlLoopEvent.class.isAssignableFrom(clazz)) {
+                        // this one is of interest
+                        logger.debug("TdjamController using CoderFilters: {}", cf);
+                        getTopicData(pct.getTopic());
+                    }
+                } catch (ClassNotFoundException e) {
+                    logger.error("CoderFilter refers to unknown class: {}",
+                                 cf.getCodedClass(), e);
+                }
+            }
+        }
+
+        // start all 'TopicData' instances
+        for (TopicData topicData : topicDataTable.values()) {
+            topicData.start();
+        }
+    }
+
+    @Override
+    public <T> boolean offer(T object) {
+        if (object instanceof ToscaPolicy) {
+            addToscaPolicy((ToscaPolicy) object);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Add or replace a ToscaPolicy instance. The policy is keyed by name and
+     * version.
+     *
+     * @param toscaPolicy the ToscaPolicy being added
+     * @return if a ToscaPolicy with this name/version previously existed within
+     *     this TdjamController, it is returned; otherwise, 'null' is returned.
+     */
+    public synchronized ToscaPolicy addToscaPolicy(ToscaPolicy toscaPolicy) {
+        Map<String, ToscaPolicy> level2 =
+            toscaPolicies.computeIfAbsent(toscaPolicy.getName(),
+                key -> new HashMap<String, ToscaPolicy>());
+        ToscaPolicy prev = level2.put(toscaPolicy.getVersion(), toscaPolicy);
+        if (prev != null) {
+            // update 'ControlLoopParams' entries
+            for (ControlLoopParams clp : controlLoopParams.values()) {
+                if (clp.getToscaPolicy() == prev) {
+                    clp.setToscaPolicy(toscaPolicy);
+                }
+            }
+        }
+        logger.debug("ToscaPolicy name={}, version={}, count={}, prev={}",
+            toscaPolicy.getName(), toscaPolicy.getVersion(), toscaPolicies.size(), (prev != null));
+        dumpTables();
+
+        // attempt to create a 'ControlLoopParams' instance from this object
+        ControlLoopParams params =
+            ControlLoopUtils.toControlLoopParams(toscaPolicy);
+        if (params != null) {
+            addControlLoopParams(params);
+        }
+        return prev;
+    }
+
+    /**
+     * Remove a ToscaPolicy instance associated with the specified name and
+     * version.
+     *
+     * @param name the name of the ToscaPolicy to remove
+     * @param version the version of the ToscaPolicy to remove
+     * @return the ToscaPolicy that was removed, or 'null' if not found
+     */
+    public synchronized ToscaPolicy removeToscaPolicy(String name, String version) {
+        ToscaPolicy prev = null;
+        Map<String, ToscaPolicy> level2 = toscaPolicies.get(name);
+
+        if (level2 != null && (prev = level2.remove(version)) != null) {
+            // remove all 'ControlLoopParams' entries referencing this policy
+            for (ControlLoopParams clp :
+                    new ArrayList<>(controlLoopParams.values())) {
+                if (clp.getToscaPolicy() == prev) {
+                    controlLoopParams.remove(clp.getClosedLoopControlName());
+                }
+            }
+        }
+        return prev;
+    }
+
+    /**
+     * Fetch a ToscaPolicy instance associated with the specified name and
+     * version.
+     *
+     * @param name the name of the ToscaPolicy
+     * @param version the version of the ToscaPolicy
+     * @return the ToscaPolicy, or 'null' if not found
+     */
+    public synchronized ToscaPolicy getToscaPolicy(String name, String version) {
+        Map<String, ToscaPolicy> level2 = toscaPolicies.get(name);
+        return (level2 == null ? null : level2.get(version));
+    }
+
+    /**
+     * Return a collection of all ToscaPolicy instances.
+     *
+     * @return all ToscaPolicy instances
+     */
+    public synchronized Collection<ToscaPolicy> getAllToscaPolicies() {
+        HashSet<ToscaPolicy> rval = new HashSet<>();
+        for (Map<String, ToscaPolicy> map : toscaPolicies.values()) {
+            rval.addAll(map.values());
+        }
+        return rval;
+    }
+
+    /**
+     * Add a new 'ControlLoopParams' instance -- they are keyed by
+     * 'closedLoopControlName'.
+     *
+     * @param clp the 'ControlLoopParams' instance to add
+     * @return the 'ControlLoopParams' instance previously associated with the
+     *     'closedLoopControlName' ('null' if it didn't exist)
+     */
+    public synchronized ControlLoopParams addControlLoopParams(ControlLoopParams clp) {
+        ToscaPolicy toscaPolicy =
+            getToscaPolicy(clp.getPolicyName(), clp.getPolicyVersion());
+        if (toscaPolicy == null) {
+            // there needs to be a 'ToscaPolicy' instance with a matching
+            // name/version
+            logger.debug("Missing ToscaPolicy, name={}, version={}",
+                         clp.getPolicyName(), clp.getPolicyVersion());
+            return clp;
+        }
+
+        clp.setToscaPolicy(toscaPolicy);
+        ControlLoopParams prev =
+            controlLoopParams.put(clp.getClosedLoopControlName(), clp);
+
+        logger.debug("ControlLoopParams name={}, version={}, closedLoopControlName={}, count={}, prev={}",
+                     clp.getPolicyName(), clp.getPolicyVersion(),
+                     clp.getClosedLoopControlName(), controlLoopParams.size(), (prev != null));
+        dumpTables();
+        return prev;
+    }
+
+    /**
+     * Return a collection of all ControlLoopParams instances.
+     *
+     * @return all ControlLoopParams instances
+     */
+    public synchronized Collection<ControlLoopParams> getAllControlLoopParams() {
+        return new ArrayList<>(controlLoopParams.values());
+    }
+
+    /**
+     * Return a collection of all EventManager  instances.
+     *
+     * @return all EventManager instances
+     *
+     */
+    public synchronized Collection<ControlLoopEventManager> getAllEventManagers() {
+        return new ArrayList<>(eventManagers.values());
+    }
+
+    /**
+     * Return a collection of all onsetToEventManager  instances.
+     *
+     * @return all onsetToEventManager instances
+     *
+     */
+    public synchronized Collection<ControlLoopEventManager> getAllOnsetToEventManager() {
+        return new ArrayList<>(onsetToEventManager.values());
+    }
+
+    /**
+     *  Reset the controller.
+     *
+     */
+    public synchronized void reset() {
+        toscaPolicies.clear();
+        controlLoopParams.clear();
+        eventManagers.clear();
+        onsetToEventManager.clear();
+    }
+
+    @Override
+    public boolean stop() {
+        super.stop();
+
+        // stop all 'TopicData' instances
+        for (TopicData topicData : topicDataTable.values()) {
+            topicData.stop();
+        }
+        return true;
+    }
+
+    /**
+     * Remove a ControlLoopParams instance associated with the specified
+     * 'closedLoopControlName'.
+     *
+     * @param closedLoopControlName the closedLoopControlName identifying the
+     *     ControlLoopParams instance
+     * @return the 'ControlLoopParams' instance, 'null' if not found
+     */
+    public synchronized ControlLoopParams removeControlLoopParams(String closedLoopControlName) {
+        return controlLoopParams.remove(closedLoopControlName);
+    }
+
+    /**
+     * Dump out the ToscaPolicy and ControlLoopParams tables in
+     * human-readable form.
+     */
+    private void dumpTables() {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        PrintStream out = new PrintStream(bos, true);
+
+        // name(25) version(10) closedLoopControlName(...)
+
+        String format = "%-25s %-10s %s\n";
+        out.println("ToscaPolicy Table");
+        out.format(format, "Name", "Version", "");
+        out.format(format, "----", "-------", "");
+
+        for (Map<String, ToscaPolicy> level2 : toscaPolicies.values()) {
+            for (ToscaPolicy tp : level2.values()) {
+                out.format(format, tp.getName(), tp.getVersion(), "");
+            }
+        }
+
+        out.println("\nControlLoopParams Table");
+        out.format(format, "Name", "Version", "ClosedLoopControlName");
+        out.format(format, "----", "-------", "---------------------");
+        for (ControlLoopParams cp : controlLoopParams.values()) {
+            out.format(format, cp.getPolicyName(), cp.getPolicyVersion(),
+                       cp.getClosedLoopControlName());
+        }
+
+        logger.debug(new String(bos.toByteArray()));
+    }
+
+    /**
+     * Find or create a 'TopicData' instance associated with the specified
+     * topic name.
+     *
+     * @param name the topic name
+     * @return the new or existing 'TopicData' instance associated with 'name'
+     */
+    private TopicData getTopicData(String name) {
+        return topicDataTable.computeIfAbsent(name, key -> new TopicData(name));
+    }
+
+    /* ============================================================ */
+
+    /**
+     * Process an incoming 'ControlLoopEvent'.
+     *
+     * @param event the incoming 'ControlLoopEvent'
+     */
+    private void processEvent(ControlLoopEvent event) {
+        String clName = event.getClosedLoopControlName();
+        ControlLoopParams params = controlLoopParams.get(clName);
+        if (params == null) {
+            logger.debug("No ControlLoopParams for event: {}", event);
+            return;
+        }
+
+        UUID requestId = event.getRequestId();
+        if (event instanceof CanonicalOnset) {
+            CanonicalOnset coEvent = (CanonicalOnset) event;
+
+            if (requestId == null) {
+                // the requestId should not be 'null'
+                handleNullRequestId(coEvent, params);
+                return;
+            }
+
+            ControlLoopEventManager manager = onsetToEventManager.computeIfAbsent(coEvent, key -> {
+                // a ControlLoopEventManager does not yet exist for this
+                // 'event' -- create one, with the initial event
+                try {
+                    ControlLoopEventManager mgr = new ControlLoopEventManager(params, coEvent);
+                    eventManagers.put(requestId, mgr);
+                    return mgr;
+                } catch (ControlLoopException e) {
+                    logger.error("Exception creating ControlLoopEventManager", e);
+                    return null;
+                }
+            });
+
+            if (manager != null && !manager.getSerialWorkQueue().isRunning()) {
+                // new manager - start it by processing the initial event
+                manager.getSerialWorkQueue().start();
+                return;
+            }
+        }
+
+        if (event instanceof VirtualControlLoopEvent) {
+            ControlLoopEventManager manager = eventManagers.get(requestId);
+            if (manager != null) {
+                manager.getSerialWorkQueue()
+                                .queueAndRun(() -> manager.subsequentEvent((VirtualControlLoopEvent) event));
+                return;
+            }
+        }
+
+        // this block of code originally appeared in the 'EVENT.CLEANUP'
+        // Drools rule
+        String ruleName = "EVENT.CLEANUP";
+
+        logger.info("{}: {}", clName, ruleName);
+        logger.debug("{}: {}: orphan event={}", clName, ruleName, event);
+    }
+
+    /**
+     * Generate and send a notification message in response to a 'CanonicalOnset'
+     * with a null 'requestId'.
+     *
+     * @param event the CanonicalOnset event
+     * @param params the associated ControlLoopParams
+     */
+    private void handleNullRequestId(CanonicalOnset event,
+                                     ControlLoopParams params) {
+        // this block of code originally appeared in the 'EVENT' Drools rule
+        String ruleName = "EVENT";
+        String clName = event.getClosedLoopControlName();
+
+        VirtualControlLoopNotification notification =
+            new VirtualControlLoopNotification(event);
+        notification.setNotification(ControlLoopNotificationType.REJECTED);
+        notification.setFrom("policy");
+        notification.setMessage("Missing requestId");
+        notification.setPolicyName(params.getPolicyName() + "." + ruleName);
+        notification.setPolicyScope(params.getPolicyScope());
+        notification.setPolicyVersion(params.getPolicyVersion());
+
+        //
+        // Generate notification
+        //
+        try {
+            PolicyEngineConstants.getManager().deliver("POLICY-CL-MGT", notification);
+
+        } catch (RuntimeException e) {
+            logger.warn("{}: {}.{}: event={} exception generating notification",
+                        clName, params.getPolicyName(), ruleName,
+                        event, e);
+        }
+    }
+
+    /* ============================================================ */
+
+    /**
+     * This nested class corresponds to a single topic name. At present, the
+     * only topics that are directly handled by this class are
+     * 'ControlLoopEvent', and subclasses (hence, the call to 'processEvent').
+     * If other event types later need to be directly handled, this may need to
+     * become an abstract class, with subclasses for the various event types.
+     */
+    private class TopicData implements TopicListener {
+        // topic name
+        private String name;
+
+        // set of 'TopicSource' instances associated with this topic
+        // (probably only one, but the underlying APIs support a list)
+        private List<TopicSource> topicSources = null;
+
+        /**
+         * Constructor -- initialize the 'TopicData' instance.
+         *
+         * @param name the topic name
+         */
+        private TopicData(String name) {
+            this.name = name;
+        }
+
+        /**
+         * Register all of the 'TopicSource' instances associated with this
+         * topic, and start the listeners.
+         */
+        private void start() {
+            if (topicSources == null) {
+                // locate topic sources
+                ArrayList<String> topics = new ArrayList<>();
+                topics.add(name);
+                topicSources = TopicEndpointManager.getManager().getTopicSources(topics);
+            }
+
+            for (TopicSource consumer : topicSources) {
+                consumer.register(this);
+                consumer.start();
+            }
+        }
+
+        /**
+         * Unregister all of the 'TopicSource' instances associated with this
+         * topic, and stop the listeners.
+         */
+        private void stop() {
+            if (topicSources != null) {
+                for (TopicSource consumer : topicSources) {
+                    consumer.unregister(this);
+                    consumer.stop();
+                }
+            }
+        }
+
+        /*===========================*/
+        /* 'TopicListener' interface */
+        /*===========================*/
+
+        @Override
+        public void onTopicEvent(Topic.CommInfrastructure commType, String topic, String event) {
+            logger.debug("TopicData.onTopicEvent: {}", event);
+            Object decodedObject =
+                EventProtocolCoderConstants.getManager().decode(groupId, artifactId, topic, event);
+            if (decodedObject != null) {
+                logger.debug("Decoded to object of {}", decodedObject.getClass());
+                if (decodedObject instanceof ControlLoopEvent) {
+                    PolicyEngineConstants.getManager().getExecutorService().execute(() ->
+                        processEvent((ControlLoopEvent) decodedObject));
+                }
+            }
+        }
+    }
+
+    /* ============================================================ */
+
+    /**
+     * This is a 'ControlLoopEventManager2' variant designed to run under
+     * 'TdjamController'.
+     */
+    private class ControlLoopEventManager extends ControlLoopEventManager2 {
+        private static final long serialVersionUID = 1L;
+
+        // used to serialize method calls from multiple threads, which avoids the
+        // need for additional synchronization
+        private final SerialWorkQueue serialWorkQueue;
+
+        private final ControlLoopParams params;
+
+        // onset event
+        private final CanonicalOnset event;
+
+        /**
+         * Constructor - initialize a ControlLoopEventManager.
+         *
+         * @param params the 'ControlLoopParam's instance associated with the
+         *     'closedLoopControlName'
+         * @param event the initial ControlLoopEvent
+         */
+        private ControlLoopEventManager(ControlLoopParams params, CanonicalOnset event)
+            throws ControlLoopException {
+
+            super(params, event);
+            this.params = params;
+            this.event = event;
+            this.serialWorkQueue = new SerialWorkQueue(this::initialEvent);
+        }
+
+        /**
+         * Return the SerialWorkQueue.
+         *
+         * @return the SerialWorkQueue
+         */
+        private SerialWorkQueue getSerialWorkQueue() {
+            return serialWorkQueue;
+        }
+
+        /**
+         * This is a notification from the base class that a state transition
+         * has occurred.
+         */
+        @Override
+        protected void notifyUpdate() {
+            update();
+        }
+
+        /**
+         * Process the initial event from DCAE that caused the
+         * 'ControlLoopEventManager' to be created.
+         */
+        private void initialEvent() {
+            // this block of code originally appeared in the 'EVENT' Drools rule
+            String ruleName = "EVENT";
+            UUID requestId = event.getRequestId();
+            String clName = event.getClosedLoopControlName();
+
+            VirtualControlLoopNotification notification;
+
+            try {
+                //
+                // Check the event, because we need it to not be null when
+                // we create the ControlLoopEventManager. The ControlLoopEventManager
+                // will do extra syntax checking as well as check if the closed loop is disabled.
+                //
+                try {
+                    start();
+                } catch (Exception e) {
+                    eventManagers.remove(requestId, this);
+                    onsetToEventManager.remove(event, this);
+                    throw e;
+                }
+                notification = makeNotification();
+                notification.setNotification(ControlLoopNotificationType.ACTIVE);
+                notification.setPolicyName(params.getPolicyName() + "." + ruleName);
+            } catch (Exception e) {
+                logger.warn("{}: {}.{}", clName, params.getPolicyName(), ruleName, e);
+                notification = new VirtualControlLoopNotification(event);
+                notification.setNotification(ControlLoopNotificationType.REJECTED);
+                notification.setMessage("Exception occurred: " + e.getMessage());
+                notification.setPolicyName(params.getPolicyName() + "." + ruleName);
+                notification.setPolicyScope(params.getPolicyScope());
+                notification.setPolicyVersion(params.getPolicyVersion());
+            }
+            //
+            // Generate notification
+            //
+            try {
+                PolicyEngineConstants.getManager().deliver("POLICY-CL-MGT", notification);
+
+            } catch (RuntimeException e) {
+                logger.warn("{}: {}.{}: event={} exception generating notification",
+                            clName, params.getPolicyName(), ruleName,
+                            event, e);
+            }
+        }
+
+        /**
+         * Process a subsequent event from DCAE.
+         *
+         * @param event the VirtualControlLoopEvent event
+         */
+        private void subsequentEvent(VirtualControlLoopEvent event) {
+            // this block of code originally appeared in the
+            // 'EVENT.MANAGER>NEW.EVENT' Drools rule
+            String ruleName = "EVENT.MANAGER.NEW.EVENT";
+
+            //
+            // Check what kind of event this is
+            //
+            switch (onNewEvent(event)) {
+                case SYNTAX_ERROR:
+                    //
+                    // Ignore any bad syntax events
+                    //
+                    logger.warn("{}: {}.{}: syntax error",
+                                getClosedLoopControlName(), getPolicyName(), ruleName);
+                    break;
+
+                case FIRST_ABATEMENT:
+                case SUBSEQUENT_ABATEMENT:
+                    //
+                    // TODO: handle the abatement.  Currently, it's just discarded.
+                    //
+                    break;
+
+                case FIRST_ONSET:
+                case SUBSEQUENT_ONSET:
+                default:
+                    //
+                    // We don't care about subsequent onsets
+                    //
+                    logger.warn("{}: {}.{}: subsequent onset",
+                                getClosedLoopControlName(), getPolicyName(), ruleName);
+                    break;
+            }
+        }
+
+        /**
+         * Called when a state transition occurs.
+         */
+        private void update() {
+            // handle synchronization by running it under the SerialWorkQueue
+            getSerialWorkQueue().queueAndRun(() -> {
+                if (isActive()) {
+                    updateActive();
+                } else {
+                    updateInactive();
+                }
+            });
+        }
+
+        /**
+         * Called when a state transition occurs, and we are in the active state.
+         */
+        private void updateActive() {
+            if (!isUpdated()) {
+                // no notification needed
+                return;
+            }
+
+            // this block of code originally appeared in the
+            // 'EVENT.MANAGER.PROCESSING' Drools rule
+            String ruleName = "EVENT.MANAGER.PROCESSING";
+            VirtualControlLoopNotification notification =
+                getNotification();
+
+            logger.info("{}: {}.{}: manager={}",
+                        getClosedLoopControlName(), getPolicyName(), ruleName,
+                        this);
+            //
+            // Generate notification
+            //
+            try {
+                notification.setPolicyName(getPolicyName() + "." + ruleName);
+                PolicyEngineConstants.getManager().deliver("POLICY-CL-MGT", notification);
+
+            } catch (RuntimeException e) {
+                logger.warn("{}: {}.{}: manager={} exception generating notification",
+                            getClosedLoopControlName(), getPolicyName(), ruleName,
+                            this, e);
+            }
+            //
+            // Generate Response notification
+            //
+            try {
+                ControlLoopResponse clResponse = getControlLoopResponse();
+                if (clResponse != null) {
+                    PolicyEngineConstants.getManager().deliver("DCAE_CL_RSP", clResponse);
+                }
+
+            } catch (RuntimeException e) {
+                logger.warn("{}: {}.{}: manager={} exception generating Response notification",
+                            getClosedLoopControlName(), getPolicyName(), ruleName,
+                            this, e);
+            }
+            //
+            // Discard this message and wait for the next response.
+            //
+            nextStep();
+            update();
+        }
+
+        /**
+         * Called when a state transition has occurred, and we are not in the
+         * active state.
+         */
+        private void updateInactive() {
+            // this block of code originally appeared in the 'EVENT.MANAGER.FINAL'
+            // Drools rule
+            String ruleName = "EVENT.MANAGER.FINAL";
+            VirtualControlLoopNotification notification =
+                getNotification();
+
+            logger.info("{}: {}.{}: manager={}",
+                        getClosedLoopControlName(), getPolicyName(), ruleName,
+                        this);
+            //
+            // Generate notification
+            //
+            try {
+                notification.setPolicyName(getPolicyName() + "." + ruleName);
+                PolicyEngineConstants.getManager().deliver("POLICY-CL-MGT", notification);
+            } catch (RuntimeException e) {
+                logger.warn("{}: {}.{}: manager={} exception generating notification",
+                            getClosedLoopControlName(), getPolicyName(), ruleName,
+                            this, e);
+            }
+            //
+            // Destroy the manager
+            //
+            destroy();
+
+            // Remove the entry from the table
+            eventManagers.remove(getRequestId(), this);
+            onsetToEventManager.remove(event, this);
+        }
+    }
+
+    /* ============================================================ */
+
+    /**
+     * An instance of this class is called by 'IndexedPolicyControllerFactory'.
+     * It does the build operation when the value of the 'controller.type'
+     * property matches the value of TDJAM_CONTROLLER_BUILDER_TAG.
+     */
+    public static class PolicyBuilder implements PolicyControllerFeatureApi {
+        @Override
+        public int getSequenceNumber() {
+            return 1;
+        }
+
+        @Override
+        public PolicyController beforeInstance(String name, Properties properties) {
+            if (TDJAM_CONTROLLER_BUILDER_TAG.equals(properties.getProperty(PROPERTY_CONTROLLER_TYPE))) {
+                return new TdjamController(name, properties);
+            }
+            return null;
+        }
+    }
+
+    /* ============================================================ */
+
+    /**
+     * An instance of this class is called by 'IndexedDroolsControllerFactory'.
+     * It does the build operation when the value of the 'controller.type'
+     * property matches the value of TDJAM_CONTROLLER_BUILDER_TAG.
+     */
+    public static class DroolsBuilder implements DroolsControllerFeatureApi {
+        @Override
+        public int getSequenceNumber() {
+            return 1;
+        }
+
+        @Override
+        public DroolsController beforeInstance(Properties properties,
+                                      String groupId, String artifactId, String version,
+                                      List<TopicCoderFilterConfiguration> decoderConfigurations,
+                                      List<TopicCoderFilterConfiguration> encoderConfigurations) throws LinkageError {
+
+            if (TDJAM_CONTROLLER_BUILDER_TAG.equals(properties.getProperty(PROPERTY_CONTROLLER_TYPE))) {
+                return TdjamController.getBuildInProgress();
+            }
+            return null;
+        }
+    }
+}
diff --git a/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/extension/system/NonDroolsPolicyController.java b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/extension/system/NonDroolsPolicyController.java
new file mode 100644
index 000000000..d876bee96
--- /dev/null
+++ b/controlloop/common/controller-tdjam/src/main/java/org/onap/policy/extension/system/NonDroolsPolicyController.java
@@ -0,0 +1,668 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.extension.system;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import org.apache.commons.collections4.queue.CircularFifoQueue;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.onap.policy.common.endpoints.event.comm.Topic;
+import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;
+import org.onap.policy.common.endpoints.event.comm.TopicSink;
+import org.onap.policy.common.endpoints.event.comm.TopicSource;
+import org.onap.policy.common.endpoints.properties.PolicyEndPointProperties;
+import org.onap.policy.common.utils.services.OrderedServiceImpl;
+import org.onap.policy.drools.controller.DroolsController;
+import org.onap.policy.drools.core.PolicyContainer;
+import org.onap.policy.drools.features.DroolsControllerFeatureApi;
+import org.onap.policy.drools.features.DroolsControllerFeatureApiConstants;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoder;
+import org.onap.policy.drools.protocol.coders.EventProtocolCoderConstants;
+import org.onap.policy.drools.protocol.coders.EventProtocolParams;
+import org.onap.policy.drools.protocol.coders.JsonProtocolFilter;
+import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration;
+import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration.CustomGsonCoder;
+import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration.PotentialCoderFilter;
+import org.onap.policy.drools.system.internal.AggregatedPolicyController;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class combines the 'PolicyController' and 'DroolsController'
+ * interfaces, and provides a controller that does not have Drools running
+ * underneath. It also contains some code copied from 'MavenDroolsController'
+ * and 'NullDroolsController'. The goal is to have it look like other
+ * controllers, use the same style property file, and provide access to
+ * UEB/DMAAP message streams associated with the controller.
+ */
+public class NonDroolsPolicyController extends AggregatedPolicyController implements DroolsController {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = LoggerFactory.getLogger(NonDroolsPolicyController.class);
+
+    /**
+     * The PolicyController and DroolsController factories assume that the
+     * controllers are separate objects, but in this case, the same object
+     * is used for both. We want the DroolsController 'build' method to
+     * return the same object; however, at the point the DroolsController
+     * build is taking place, the PolicyController hasn't yet been placed
+     * in any tables. The following variable is used to pass this information
+     * from one stack frame to another within the same thread.
+     */
+    private static ThreadLocal<NonDroolsPolicyController> buildInProgress = new ThreadLocal<>();
+
+    /**
+     * alive status of this drools controller,
+     * reflects invocation of start()/stop() only.
+     */
+    protected volatile boolean alive = false;
+
+    /**
+     * locked status of this drools controller,
+     * reflects if i/o drools related operations are permitted,
+     * more specifically: offer() and deliver().
+     * It does not affect the ability to start and stop
+     * underlying drools infrastructure
+     */
+    protected volatile boolean locked = false;
+
+    /**
+     * list of topics, each with associated decoder classes, each
+     * with a list of associated filters.
+     */
+    protected List<TopicCoderFilterConfiguration> decoderConfigurations;
+
+    /**
+     * list of topics, each with associated encoder classes, each
+     * with a list of associated filters.
+     */
+    protected List<TopicCoderFilterConfiguration> encoderConfigurations;
+
+    /**
+     * recent sink events processed.
+     */
+    protected final CircularFifoQueue<String> recentSinkEvents = new CircularFifoQueue<>(10);
+
+    // this is used to avoid infinite recursion in a shutdown or halt operation
+    private boolean shutdownInProgress = false;
+
+    private static Properties convert(String name, Properties properties) {
+
+        Properties newProperties = new Properties();
+        for (String pname : properties.stringPropertyNames()) {
+            newProperties.setProperty(pname, properties.getProperty(pname));
+        }
+
+        newProperties.setProperty("rules.groupId", "NonDroolsPolicyController");
+        newProperties.setProperty("rules.artifactId", name);
+        newProperties.setProperty("rules.version", "1.0");
+        return newProperties;
+    }
+
+    /**
+     * constructor -- pass parameters to superclass.
+     * @param name controller name
+     * @param properties contents of controller properties file
+     */
+    public NonDroolsPolicyController(String name, Properties properties) {
+        super(name, convert(name, properties));
+    }
+
+    /**
+     * This is used to pass the 'NonDroolsPolicyController' object to the
+     * 'DroolsPolicyBuilder' object, as the same object is used for both
+     * 'PolicyController' and 'DroolsController'.
+     *
+     * @return the NonDroolsPolicyController object ('null' if not available)
+     */
+    public static NonDroolsPolicyController getBuildInProgress() {
+        return buildInProgress.get();
+    }
+
+    protected void initDrools(Properties properties) {
+        try {
+            // Register with drools factory
+            buildInProgress.set(this);
+            this.droolsController.set(getDroolsFactory().build(properties, sources, sinks));
+            buildInProgress.set(null);
+        } catch (Exception | LinkageError e) {
+            logger.error("{}: cannot init-drools", this);
+            throw new IllegalArgumentException(e);
+        }
+
+        decoderConfigurations = codersAndFilters(properties, sources);
+        encoderConfigurations = codersAndFilters(properties, sinks);
+
+        // add to 'EventProtocolCoderConstants.getManager()' table
+        for (TopicCoderFilterConfiguration tcfc : decoderConfigurations) {
+            for (PotentialCoderFilter pcf : tcfc.getCoderFilters()) {
+                getCoderManager().addDecoder(
+                    EventProtocolParams.builder()
+                    .groupId(getGroupId())
+                    .artifactId(getArtifactId())
+                    .topic(tcfc.getTopic())
+                    .eventClass(pcf.getCodedClass())
+                    .protocolFilter(pcf.getFilter())
+                    .customGsonCoder(tcfc.getCustomGsonCoder())
+                    .modelClassLoaderHash(NonDroolsPolicyController.class.getClassLoader().hashCode()));
+            }
+        }
+        for (TopicCoderFilterConfiguration tcfc : encoderConfigurations) {
+            for (PotentialCoderFilter pcf : tcfc.getCoderFilters()) {
+                getCoderManager().addEncoder(
+                    EventProtocolParams.builder()
+                    .groupId(getGroupId())
+                    .artifactId(getArtifactId())
+                    .topic(tcfc.getTopic())
+                    .eventClass(pcf.getCodedClass())
+                    .protocolFilter(pcf.getFilter())
+                    .customGsonCoder(tcfc.getCustomGsonCoder())
+                    .modelClassLoaderHash(NonDroolsPolicyController.class.getClassLoader().hashCode()));
+            }
+        }
+    }
+
+    /*==============================*/
+    /* 'DroolsController' interface */
+    /*==============================*/
+
+    // methods copied from 'MavenDroolsController' and 'NullDroolsController'
+
+    @Override
+    public boolean start() {
+
+        logger.info("START: {}", this);
+
+        synchronized (this) {
+            if (this.alive) {
+                return true;
+            }
+            this.alive = true;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean stop() {
+
+        logger.info("STOP: {}", this);
+
+        synchronized (this) {
+            if (!this.alive) {
+                return true;
+            }
+            this.alive = false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void shutdown() {
+        if (shutdownInProgress) {
+            // avoid infinite recursion
+            return;
+        }
+        logger.info("{}: SHUTDOWN", this);
+
+        try {
+            this.stop();
+            this.removeCoders();
+            shutdownInProgress = true;
+
+            // the following method calls 'this.shutdown' recursively
+            getDroolsFactory().shutdown(this);
+        } catch (Exception e) {
+            logger.error("{} SHUTDOWN FAILED because of {}", this, e.getMessage(), e);
+        } finally {
+            shutdownInProgress = false;
+        }
+    }
+
+    @Override
+    public void halt() {
+        if (shutdownInProgress) {
+            // avoid infinite recursion
+            return;
+        }
+        logger.info("{}: HALT", this);
+
+        try {
+            this.stop();
+            this.removeCoders();
+            shutdownInProgress = true;
+
+            // the following method calls 'this.halt' recursively
+            getDroolsFactory().destroy(this);
+        } catch (Exception e) {
+            logger.error("{} HALT FAILED because of {}", this, e.getMessage(), e);
+        } finally {
+            shutdownInProgress = false;
+        }
+    }
+
+    @Override
+    public boolean isAlive() {
+        return this.alive;
+    }
+
+    @Override
+    public boolean lock() {
+        logger.info("LOCK: {}",  this);
+
+        this.locked = true;
+        return true;
+    }
+
+    @Override
+    public boolean unlock() {
+        logger.info("UNLOCK: {}",  this);
+
+        this.locked = false;
+        return true;
+    }
+
+    @Override
+    public boolean isLocked() {
+        return this.locked;
+    }
+
+    @Override
+    public String getGroupId() {
+        return "NonDroolsPolicyController";
+    }
+
+    @Override
+    public String getArtifactId() {
+        return getName();
+    }
+
+    @Override
+    public String getVersion() {
+        return "1.0";
+    }
+
+    @Override
+    public List<String> getSessionNames() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<String> getCanonicalSessionNames() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<String> getBaseDomainNames() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean offer(String topic, String event) {
+        return false;
+    }
+
+    @Override
+    public <T> boolean offer(T event) {
+        return false;
+    }
+
+    @Override
+    public boolean deliver(TopicSink sink, Object event) {
+
+        // this one is from 'MavenDroolsController'
+
+        logger.info("{} DELIVER: {} FROM {} TO {}", this, event, this, sink);
+
+        for (DroolsControllerFeatureApi feature : getDroolsProviders().getList()) {
+            try {
+                if (feature.beforeDeliver(this, sink, event)) {
+                    return true;
+                }
+            } catch (Exception e) {
+                logger.error("{}: feature {} before-deliver failure because of {}", this, feature.getClass().getName(),
+                        e.getMessage(), e);
+            }
+        }
+
+        if (sink == null) {
+            throw new IllegalArgumentException(this +  " invalid sink");
+        }
+
+        if (event == null) {
+            throw new IllegalArgumentException(this +  " invalid event");
+        }
+
+        if (this.locked) {
+            throw new IllegalStateException(this +  " is locked");
+        }
+
+        if (!this.alive) {
+            throw new IllegalStateException(this +  " is stopped");
+        }
+
+        String json =
+                getCoderManager().encode(sink.getTopic(), event, this);
+
+        synchronized (this.recentSinkEvents) {
+            this.recentSinkEvents.add(json);
+        }
+
+        boolean success = sink.send(json);
+
+        for (DroolsControllerFeatureApi feature : getDroolsProviders().getList()) {
+            try {
+                if (feature.afterDeliver(this, sink, event, json, success)) {
+                    return true;
+                }
+            } catch (Exception e) {
+                logger.error("{}: feature {} after-deliver failure because of {}", this, feature.getClass().getName(),
+                        e.getMessage(), e);
+            }
+        }
+
+        return success;
+
+    }
+
+    @Override
+    public Object[] getRecentSourceEvents() {
+        return new String[0];
+    }
+
+    @Override
+    public PolicyContainer getContainer() {
+        return null;
+    }
+
+    @Override
+    public String[] getRecentSinkEvents() {
+        synchronized (this.recentSinkEvents) {
+            String[] events = new String[recentSinkEvents.size()];
+            return recentSinkEvents.toArray(events);
+        }
+    }
+
+    @Override
+    public boolean ownsCoder(Class<?> coderClass, int modelHash) {
+        //throw new IllegalStateException(makeInvokeMsg());
+        return true;
+    }
+
+    @Override
+    public Class<?> fetchModelClass(String className) {
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException(makeInvokeMsg());
+        }
+    }
+
+    @Override
+    public boolean isBrained() {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("NonDroolsPolicyController []");
+        return builder.toString();
+    }
+
+    @Override
+    public void updateToVersion(String newGroupId, String newArtifactId, String newVersion,
+            List<TopicCoderFilterConfiguration> decoderConfigurations,
+            List<TopicCoderFilterConfiguration> encoderConfigurations)
+                    throws LinkageError {
+        throw new IllegalStateException(makeInvokeMsg());
+    }
+
+    @Override
+    public Map<String, Integer> factClassNames(String sessionName) {
+        return new HashMap<>();
+    }
+
+    @Override
+    public long factCount(String sessionName) {
+        return 0;
+    }
+
+    @Override
+    public List<Object> facts(String sessionName, String className, boolean delete) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public <T> List<T> facts(@NonNull String sessionName, @NonNull Class<T> clazz) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<Object> factQuery(String sessionName, String queryName,
+            String queriedEntity,
+            boolean delete, Object... queryParams) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public <T> boolean delete(@NonNull String sessionName, @NonNull T fact) {
+        return false;
+    }
+
+    @Override
+    public <T> boolean delete(@NonNull T fact) {
+        return false;
+    }
+
+    @Override
+    public <T> boolean delete(@NonNull String sessionName, @NonNull Class<T> fact) {
+        return false;
+    }
+
+    @Override
+    public <T> boolean delete(@NonNull Class<T> fact) {
+        return false;
+    }
+
+    private String makeInvokeMsg() {
+        return this.getClass().getName() + " invoked";
+    }
+
+    /**
+     * remove decoders.
+     */
+    protected void removeDecoders() {
+        logger.info("REMOVE-DECODERS: {}", this);
+
+        if (this.decoderConfigurations == null) {
+            return;
+        }
+
+
+        for (TopicCoderFilterConfiguration coderConfig: decoderConfigurations) {
+            String topic = coderConfig.getTopic();
+            getCoderManager().removeDecoders(this.getGroupId(), this.getArtifactId(), topic);
+        }
+    }
+
+    /**
+     * remove decoders.
+     */
+    protected void removeEncoders() {
+
+        logger.info("REMOVE-ENCODERS: {}", this);
+
+        if (this.encoderConfigurations == null) {
+            return;
+        }
+
+        for (TopicCoderFilterConfiguration coderConfig: encoderConfigurations) {
+            String topic = coderConfig.getTopic();
+            getCoderManager().removeEncoders(this.getGroupId(), this.getArtifactId(), topic);
+        }
+    }
+
+    /**
+     * removes this drools controllers and encoders and decoders from operation.
+     */
+    protected void removeCoders() {
+        logger.info("{}: REMOVE-CODERS", this);
+
+        try {
+            this.removeDecoders();
+        } catch (IllegalArgumentException e) {
+            logger.error("{} REMOVE-DECODERS FAILED because of {}", this, e.getMessage(), e);
+        }
+
+        try {
+            this.removeEncoders();
+        } catch (IllegalArgumentException e) {
+            logger.error("{} REMOVE-ENCODERS FAILED because of {}", this, e.getMessage(), e);
+        }
+    }
+
+    protected List<TopicCoderFilterConfiguration> codersAndFilters(Properties properties,
+            List<? extends Topic> topicEntities) {
+
+        List<TopicCoderFilterConfiguration> topics2DecodedClasses2Filters = new ArrayList<>();
+
+        if (topicEntities == null || topicEntities.isEmpty()) {
+            return topics2DecodedClasses2Filters;
+        }
+
+        for (Topic topic : topicEntities) {
+
+            // 1. first the topic
+
+            String firstTopic = topic.getTopic();
+
+            String propertyTopicEntityPrefix = getPropertyTopicPrefix(topic) + firstTopic;
+
+            // 2. check if there is a custom decoder for this topic that the user prefers to use
+            // instead of the ones provided in the platform
+
+            CustomGsonCoder customGsonCoder = getCustomCoder(properties, propertyTopicEntityPrefix);
+
+            // 3. second the list of classes associated with each topic
+
+            String eventClasses = properties
+                    .getProperty(propertyTopicEntityPrefix + PolicyEndPointProperties.PROPERTY_TOPIC_EVENTS_SUFFIX);
+
+            if (eventClasses == null || eventClasses.isEmpty()) {
+                logger.warn("There are no event classes for topic {}", firstTopic);
+                continue;
+            }
+
+            List<PotentialCoderFilter> classes2Filters =
+                            getFilterExpressions(properties, propertyTopicEntityPrefix, eventClasses);
+
+            TopicCoderFilterConfiguration topic2Classes2Filters =
+                    new TopicCoderFilterConfiguration(firstTopic, classes2Filters, customGsonCoder);
+            topics2DecodedClasses2Filters.add(topic2Classes2Filters);
+        }
+
+        return topics2DecodedClasses2Filters;
+    }
+
+    private String getPropertyTopicPrefix(Topic topic) {
+        boolean isSource = topic instanceof TopicSource;
+        CommInfrastructure commInfra = topic.getTopicCommInfrastructure();
+        if (commInfra == CommInfrastructure.UEB) {
+            if (isSource) {
+                return PolicyEndPointProperties.PROPERTY_UEB_SOURCE_TOPICS + ".";
+            } else {
+                return PolicyEndPointProperties.PROPERTY_UEB_SINK_TOPICS + ".";
+            }
+        } else if (commInfra == CommInfrastructure.DMAAP) {
+            if (isSource) {
+                return PolicyEndPointProperties.PROPERTY_DMAAP_SOURCE_TOPICS + ".";
+            } else {
+                return PolicyEndPointProperties.PROPERTY_DMAAP_SINK_TOPICS + ".";
+            }
+        } else if (commInfra == CommInfrastructure.NOOP) {
+            if (isSource) {
+                return PolicyEndPointProperties.PROPERTY_NOOP_SOURCE_TOPICS + ".";
+            } else {
+                return PolicyEndPointProperties.PROPERTY_NOOP_SINK_TOPICS + ".";
+            }
+        } else {
+            throw new IllegalArgumentException("Invalid Communication Infrastructure: " + commInfra);
+        }
+    }
+
+    private CustomGsonCoder getCustomCoder(Properties properties, String propertyPrefix) {
+        String customGson = properties.getProperty(propertyPrefix
+                + PolicyEndPointProperties.PROPERTY_TOPIC_EVENTS_CUSTOM_MODEL_CODER_GSON_SUFFIX);
+
+        CustomGsonCoder customGsonCoder = null;
+        if (customGson != null && !customGson.isEmpty()) {
+            try {
+                customGsonCoder = new CustomGsonCoder(customGson);
+            } catch (IllegalArgumentException e) {
+                logger.warn("{}: cannot create custom-gson-coder {} because of {}", this, customGson,
+                        e.getMessage(), e);
+            }
+        }
+        return customGsonCoder;
+    }
+
+    private List<PotentialCoderFilter> getFilterExpressions(Properties properties, String propertyPrefix,
+                    String eventClasses) {
+
+        List<PotentialCoderFilter> classes2Filters = new ArrayList<>();
+
+        List<String> topicClasses = new ArrayList<>(Arrays.asList(eventClasses.split("\\s*,\\s*")));
+
+        for (String theClass : topicClasses) {
+
+            // 4. for each coder class, get the filter expression
+
+            String filter = properties
+                    .getProperty(propertyPrefix
+                            + PolicyEndPointProperties.PROPERTY_TOPIC_EVENTS_SUFFIX
+                            + "." + theClass + PolicyEndPointProperties.PROPERTY_TOPIC_EVENTS_FILTER_SUFFIX);
+
+            JsonProtocolFilter protocolFilter = new JsonProtocolFilter(filter);
+            PotentialCoderFilter class2Filters = new PotentialCoderFilter(theClass, protocolFilter);
+            classes2Filters.add(class2Filters);
+        }
+
+        return classes2Filters;
+    }
+
+    // these may be overridden by junit tests
+
+    protected EventProtocolCoder getCoderManager() {
+        return EventProtocolCoderConstants.getManager();
+    }
+
+    protected OrderedServiceImpl<DroolsControllerFeatureApi> getDroolsProviders() {
+        return DroolsControllerFeatureApiConstants.getProviders();
+    }
+}
diff --git a/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.DroolsControllerFeatureApi b/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.DroolsControllerFeatureApi
new file mode 100644
index 000000000..09a087ee6
--- /dev/null
+++ b/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.DroolsControllerFeatureApi
@@ -0,0 +1 @@
+org.onap.policy.controlloop.tdjam.TdjamController$DroolsBuilder
diff --git a/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyControllerFeatureApi b/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyControllerFeatureApi
new file mode 100644
index 000000000..dad467869
--- /dev/null
+++ b/controlloop/common/controller-tdjam/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyControllerFeatureApi
@@ -0,0 +1 @@
+org.onap.policy.controlloop.tdjam.TdjamController$PolicyBuilder