diff options
Diffstat (limited to 'controlloop/common/controller-tdjam/src/main')
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 |