2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2020 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.drools.controller.internal;
23 import com.fasterxml.jackson.annotation.JsonIgnore;
24 import com.fasterxml.jackson.annotation.JsonProperty;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.HashMap;
28 import java.util.List;
30 import java.util.Objects;
31 import java.util.stream.Collectors;
32 import org.apache.commons.collections4.queue.CircularFifoQueue;
33 import org.checkerframework.checker.nullness.qual.NonNull;
34 import org.drools.core.ClassObjectFilter;
35 import org.kie.api.definition.KiePackage;
36 import org.kie.api.definition.rule.Query;
37 import org.kie.api.runtime.KieSession;
38 import org.kie.api.runtime.rule.FactHandle;
39 import org.kie.api.runtime.rule.QueryResults;
40 import org.kie.api.runtime.rule.QueryResultsRow;
41 import org.onap.policy.common.endpoints.event.comm.TopicSink;
42 import org.onap.policy.common.gson.annotation.GsonJsonIgnore;
43 import org.onap.policy.common.gson.annotation.GsonJsonProperty;
44 import org.onap.policy.common.utils.services.FeatureApiUtils;
45 import org.onap.policy.common.utils.services.OrderedServiceImpl;
46 import org.onap.policy.drools.controller.DroolsController;
47 import org.onap.policy.drools.controller.DroolsControllerConstants;
48 import org.onap.policy.drools.core.PolicyContainer;
49 import org.onap.policy.drools.core.PolicySession;
50 import org.onap.policy.drools.core.jmx.PdpJmx;
51 import org.onap.policy.drools.features.DroolsControllerFeatureApi;
52 import org.onap.policy.drools.features.DroolsControllerFeatureApiConstants;
53 import org.onap.policy.drools.protocol.coders.EventProtocolCoder;
54 import org.onap.policy.drools.protocol.coders.EventProtocolCoderConstants;
55 import org.onap.policy.drools.protocol.coders.EventProtocolParams;
56 import org.onap.policy.drools.protocol.coders.JsonProtocolFilter;
57 import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration;
58 import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration.CustomGsonCoder;
59 import org.onap.policy.drools.protocol.coders.TopicCoderFilterConfiguration.PotentialCoderFilter;
60 import org.onap.policy.drools.utils.ReflectionUtil;
61 import org.slf4j.Logger;
62 import org.slf4j.LoggerFactory;
65 * Maven-based Drools Controller that interacts with the
66 * policy-core PolicyContainer and PolicySession to manage
67 * Drools containers instantiated using Maven.
69 public class MavenDroolsController implements DroolsController {
71 private static final String FACT_RETRIEVE_ERROR = "Object cannot be retrieved from fact {}";
76 private static Logger logger = LoggerFactory.getLogger(MavenDroolsController.class);
79 * Policy Container, the access object to the policy-core layer.
83 protected final PolicyContainer policyContainer;
86 * alive status of this drools controller,
87 * reflects invocation of start()/stop() only.
89 protected volatile boolean alive = false;
92 * locked status of this drools controller,
93 * reflects if i/o drools related operations are permitted,
94 * more specifically: offer() and deliver().
95 * It does not affect the ability to start and stop
96 * underlying drools infrastructure
98 protected volatile boolean locked = false;
101 * list of topics, each with associated decoder classes, each
102 * with a list of associated filters.
104 protected List<TopicCoderFilterConfiguration> decoderConfigurations;
107 * list of topics, each with associated encoder classes, each
108 * with a list of associated filters.
110 protected List<TopicCoderFilterConfiguration> encoderConfigurations;
113 * recent source events processed.
115 protected final CircularFifoQueue<Object> recentSourceEvents = new CircularFifoQueue<>(10);
118 * recent sink events processed.
120 protected final CircularFifoQueue<String> recentSinkEvents = new CircularFifoQueue<>(10);
123 * original Drools Model/Rules classloader hash.
125 protected int modelClassLoaderHash;
128 * Expanded version of the constructor.
130 * @param groupId maven group id
131 * @param artifactId maven artifact id
132 * @param version maven version
133 * @param decoderConfigurations list of topic -> decoders -> filters mapping
134 * @param encoderConfigurations list of topic -> encoders -> filters mapping
136 * @throws IllegalArgumentException invalid arguments passed in
138 public MavenDroolsController(String groupId,
141 List<TopicCoderFilterConfiguration> decoderConfigurations,
142 List<TopicCoderFilterConfiguration> encoderConfigurations) {
144 logger.info("drools-controller instantiation [{}:{}:{}]", groupId, artifactId, version);
146 if (groupId == null || groupId.isEmpty()) {
147 throw new IllegalArgumentException("Missing maven group-id coordinate");
150 if (artifactId == null || artifactId.isEmpty()) {
151 throw new IllegalArgumentException("Missing maven artifact-id coordinate");
154 if (version == null || version.isEmpty()) {
155 throw new IllegalArgumentException("Missing maven version coordinate");
158 this.policyContainer = makePolicyContainer(groupId, artifactId, version);
159 this.init(decoderConfigurations, encoderConfigurations);
161 logger.debug("{}: instantiation completed ", this);
165 * init encoding/decoding configuration.
167 * @param decoderConfigurations list of topic -> decoders -> filters mapping
168 * @param encoderConfigurations list of topic -> encoders -> filters mapping
170 protected void init(List<TopicCoderFilterConfiguration> decoderConfigurations,
171 List<TopicCoderFilterConfiguration> encoderConfigurations) {
173 this.decoderConfigurations = decoderConfigurations;
174 this.encoderConfigurations = encoderConfigurations;
176 this.initCoders(decoderConfigurations, true);
177 this.initCoders(encoderConfigurations, false);
179 this.modelClassLoaderHash = this.policyContainer.getClassLoader().hashCode();
183 public void updateToVersion(String newGroupId, String newArtifactId, String newVersion,
184 List<TopicCoderFilterConfiguration> decoderConfigurations,
185 List<TopicCoderFilterConfiguration> encoderConfigurations)
186 throws LinkageError {
188 logger.info("updating version -> [{}:{}:{}]", newGroupId, newArtifactId, newVersion);
190 validateText(newGroupId, "Missing maven group-id coordinate");
191 validateText(newArtifactId, "Missing maven artifact-id coordinate");
192 validateText(newVersion, "Missing maven version coordinate");
194 validateHasBrain(newGroupId, newArtifactId, newVersion);
196 if (newGroupId.equalsIgnoreCase(this.getGroupId())
197 && newArtifactId.equalsIgnoreCase(this.getArtifactId())
198 && newVersion.equalsIgnoreCase(this.getVersion())) {
199 logger.warn("All in the right version: {}:{}:{} vs. {}", newGroupId, newArtifactId, newVersion, this);
203 validateNewVersion(newGroupId, newArtifactId, newVersion);
206 String messages = this.policyContainer.updateToVersion(newVersion);
207 logger.warn("{} UPGRADE results: {}", this, messages);
210 * If all sucessful (can load new container), now we can remove all coders from previous sessions
217 this.init(decoderConfigurations, encoderConfigurations);
219 logger.info("UPDATE-TO-VERSION: completed {}", this);
222 private void validateText(String text, String errorMessage) {
223 if (text == null || text.isEmpty()) {
224 throw new IllegalArgumentException(errorMessage);
228 private void validateHasBrain(String newGroupId, String newArtifactId, String newVersion) {
229 if (newGroupId.equalsIgnoreCase(DroolsControllerConstants.NO_GROUP_ID)
230 || newArtifactId.equalsIgnoreCase(DroolsControllerConstants.NO_ARTIFACT_ID)
231 || newVersion.equalsIgnoreCase(DroolsControllerConstants.NO_VERSION)) {
232 throw new IllegalArgumentException("BRAINLESS maven coordinates provided: "
233 + newGroupId + ":" + newArtifactId + ":"
238 private void validateNewVersion(String newGroupId, String newArtifactId, String newVersion) {
239 if (!newGroupId.equalsIgnoreCase(this.getGroupId())
240 || !newArtifactId.equalsIgnoreCase(this.getArtifactId())) {
241 throw new IllegalArgumentException(
242 "Group ID and Artifact ID maven coordinates must be identical for the upgrade: "
243 + newGroupId + ":" + newArtifactId + ":"
244 + newVersion + " vs. " + this);
249 * initialize decoders for all the topics supported by this controller
250 * Note this is critical to be done after the Policy Container is
251 * instantiated to be able to fetch the corresponding classes.
253 * @param coderConfigurations list of topic -> decoders -> filters mapping
255 protected void initCoders(List<TopicCoderFilterConfiguration> coderConfigurations,
258 logger.info("INIT-CODERS: {}", this);
260 if (coderConfigurations == null) {
265 for (TopicCoderFilterConfiguration coderConfig: coderConfigurations) {
266 String topic = coderConfig.getTopic();
268 CustomGsonCoder customGsonCoder = getCustomCoder(coderConfig);
270 List<PotentialCoderFilter> coderFilters = coderConfig.getCoderFilters();
271 if (coderFilters == null || coderFilters.isEmpty()) {
275 for (PotentialCoderFilter coderFilter : coderFilters) {
276 String potentialCodedClass = coderFilter.getCodedClass();
277 JsonProtocolFilter protocolFilter = coderFilter.getFilter();
279 if (!isClass(potentialCodedClass)) {
280 throw makeRetrieveEx(potentialCodedClass);
282 logClassFetched(potentialCodedClass);
286 getCoderManager().addDecoder(EventProtocolParams.builder()
287 .groupId(this.getGroupId())
288 .artifactId(this.getArtifactId())
290 .eventClass(potentialCodedClass)
291 .protocolFilter(protocolFilter)
292 .customGsonCoder(customGsonCoder)
293 .modelClassLoaderHash(this.policyContainer.getClassLoader().hashCode()));
295 getCoderManager().addEncoder(
296 EventProtocolParams.builder().groupId(this.getGroupId())
297 .artifactId(this.getArtifactId()).topic(topic)
298 .eventClass(potentialCodedClass).protocolFilter(protocolFilter)
299 .customGsonCoder(customGsonCoder)
300 .modelClassLoaderHash(this.policyContainer.getClassLoader().hashCode()));
306 private CustomGsonCoder getCustomCoder(TopicCoderFilterConfiguration coderConfig) {
307 CustomGsonCoder customGsonCoder = coderConfig.getCustomGsonCoder();
308 if (customGsonCoder != null
309 && customGsonCoder.getClassContainer() != null
310 && !customGsonCoder.getClassContainer().isEmpty()) {
312 String customGsonCoderClass = customGsonCoder.getClassContainer();
313 if (!isClass(customGsonCoderClass)) {
314 throw makeRetrieveEx(customGsonCoderClass);
316 logClassFetched(customGsonCoderClass);
319 return customGsonCoder;
323 * Logs an error and makes an exception for an item that cannot be retrieved.
324 * @param itemName the item to retrieve
325 * @return a new exception
327 private IllegalArgumentException makeRetrieveEx(String itemName) {
328 logger.error("{} cannot be retrieved", itemName);
329 return new IllegalArgumentException(itemName + " cannot be retrieved");
333 * Logs the name of the class that was fetched.
334 * @param className class name fetched
336 private void logClassFetched(String className) {
337 logger.info("CLASS FETCHED {}", className);
344 protected void removeDecoders() {
345 logger.info("REMOVE-DECODERS: {}", this);
347 if (this.decoderConfigurations == null) {
352 for (TopicCoderFilterConfiguration coderConfig: decoderConfigurations) {
353 String topic = coderConfig.getTopic();
354 getCoderManager().removeDecoders(this.getGroupId(), this.getArtifactId(), topic);
361 protected void removeEncoders() {
363 logger.info("REMOVE-ENCODERS: {}", this);
365 if (this.encoderConfigurations == null) {
369 for (TopicCoderFilterConfiguration coderConfig: encoderConfigurations) {
370 String topic = coderConfig.getTopic();
371 getCoderManager().removeEncoders(this.getGroupId(), this.getArtifactId(), topic);
377 public boolean ownsCoder(Class<?> coderClass, int modelHash) {
378 if (!isClass(coderClass.getName())) {
379 logger.error("{}{} cannot be retrieved. ", this, coderClass.getName());
383 if (modelHash == this.modelClassLoaderHash) {
384 logger.info("{}{} class loader matches original drools controller rules classloader {}",
385 coderClass.getName(), this, coderClass.getClassLoader());
388 logger.warn("{}{} class loaders don't match {} vs {}", this, coderClass.getName(),
389 coderClass.getClassLoader(), this.policyContainer.getClassLoader());
395 public boolean start() {
397 logger.info("START: {}", this);
399 synchronized (this) {
406 return this.policyContainer.start();
410 public boolean stop() {
412 logger.info("STOP: {}", this);
414 synchronized (this) {
421 return this.policyContainer.stop();
425 public void shutdown() {
426 logger.info("{}: SHUTDOWN", this);
431 } catch (Exception e) {
432 logger.error("{} SHUTDOWN FAILED because of {}", this, e.getMessage(), e);
434 this.policyContainer.shutdown();
441 logger.info("{}: HALT", this);
446 } catch (Exception e) {
447 logger.error("{} HALT FAILED because of {}", this, e.getMessage(), e);
449 this.policyContainer.destroy();
454 * removes this drools controllers and encoders and decoders from operation.
456 protected void removeCoders() {
457 logger.info("{}: REMOVE-CODERS", this);
460 this.removeDecoders();
461 } catch (IllegalArgumentException e) {
462 logger.error("{} REMOVE-DECODERS FAILED because of {}", this, e.getMessage(), e);
466 this.removeEncoders();
467 } catch (IllegalArgumentException e) {
468 logger.error("{} REMOVE-ENCODERS FAILED because of {}", this, e.getMessage(), e);
473 public boolean isAlive() {
478 public boolean offer(String topic, String event) {
479 logger.debug("{}: OFFER raw event from {}", this, topic);
481 if (this.locked || !this.alive || this.policyContainer.getPolicySessions().isEmpty()) {
485 // 1. Now, check if this topic has a decoder:
487 if (!getCoderManager().isDecodingSupported(this.getGroupId(),
488 this.getArtifactId(),
491 logger.warn("{}: DECODING-UNSUPPORTED {}:{}:{}", this,
492 topic, this.getGroupId(), this.getArtifactId());
500 anEvent = getCoderManager().decode(this.getGroupId(),
501 this.getArtifactId(),
504 } catch (UnsupportedOperationException uoe) {
505 logger.debug("{}: DECODE FAILED: {} <- {} because of {}", this, topic,
506 event, uoe.getMessage(), uoe);
508 } catch (Exception e) {
509 logger.warn("{}: DECODE FAILED: {} <- {} because of {}", this, topic,
510 event, e.getMessage(), e);
514 return offer(anEvent);
519 * This method always returns "true", which causes a sonar complaint. However,
520 * refactoring or restructuring it would unnecessarily complicate it, thus we'll just
521 * disable the sonar complaint.
524 public <T> boolean offer(T event) { // NOSONAR
525 logger.debug("{}: OFFER event", this);
527 if (this.locked || !this.alive || this.policyContainer.getPolicySessions().isEmpty()) {
531 synchronized (this.recentSourceEvents) {
532 this.recentSourceEvents.add(event);
535 PdpJmx.getInstance().updateOccured();
539 if (FeatureApiUtils.apply(getDroolsProviders().getList(),
540 feature -> feature.beforeInsert(this, event),
541 (feature, ex) -> logger.error("{}: feature {} before-insert failure because of {}", this,
542 feature.getClass().getName(), ex.getMessage(), ex))) {
546 boolean successInject = this.policyContainer.insertAll(event);
547 if (!successInject) {
548 logger.warn("{} Failed to inject into PolicyContainer {}", this, this.getSessionNames());
551 FeatureApiUtils.apply(getDroolsProviders().getList(),
552 feature -> feature.afterInsert(this, event, successInject),
553 (feature, ex) -> logger.error("{}: feature {} after-insert failure because of {}", this,
554 feature.getClass().getName(), ex.getMessage(), ex));
561 public boolean deliver(TopicSink sink, Object event) {
563 logger.info("{}DELIVER: {} FROM {} TO {}", this, event, this, sink);
565 for (DroolsControllerFeatureApi feature : getDroolsProviders().getList()) {
567 if (feature.beforeDeliver(this, sink, event)) {
571 catch (Exception e) {
572 logger.error("{}: feature {} before-deliver failure because of {}", this, feature.getClass().getName(),
578 throw new IllegalArgumentException(this + " invalid sink");
582 throw new IllegalArgumentException(this + " invalid event");
586 throw new IllegalStateException(this + " is locked");
590 throw new IllegalStateException(this + " is stopped");
594 getCoderManager().encode(sink.getTopic(), event, this);
596 synchronized (this.recentSinkEvents) {
597 this.recentSinkEvents.add(json);
600 boolean success = sink.send(json);
602 for (DroolsControllerFeatureApi feature : getDroolsProviders().getList()) {
604 if (feature.afterDeliver(this, sink, event, json, success)) {
608 catch (Exception e) {
609 logger.error("{}: feature {} after-deliver failure because of {}", this, feature.getClass().getName(),
619 public String getVersion() {
620 return this.policyContainer.getVersion();
624 public String getArtifactId() {
625 return this.policyContainer.getArtifactId();
629 public String getGroupId() {
630 return this.policyContainer.getGroupId();
634 * Get model class loader hash.
636 * @return the modelClassLoaderHash
638 public int getModelClassLoaderHash() {
639 return modelClassLoaderHash;
643 public synchronized boolean lock() {
644 logger.info("LOCK: {}", this);
651 public synchronized boolean unlock() {
652 logger.info("UNLOCK: {}", this);
659 public boolean isLocked() {
666 public PolicyContainer getContainer() {
667 return this.policyContainer;
670 @JsonProperty("sessions")
671 @GsonJsonProperty("sessions")
673 public List<String> getSessionNames() {
674 return getSessionNames(true);
680 * @param abbreviated true for the short form, otherwise the long form
681 * @return session names
683 protected List<String> getSessionNames(boolean abbreviated) {
684 List<String> sessionNames = new ArrayList<>();
686 for (PolicySession session: this.policyContainer.getPolicySessions()) {
688 sessionNames.add(session.getName());
690 sessionNames.add(session.getFullName());
693 } catch (Exception e) {
694 logger.warn("Can't retrieve CORE sessions", e);
695 sessionNames.add(e.getMessage());
700 @JsonProperty("sessionCoordinates")
701 @GsonJsonProperty("sessionCoordinates")
703 public List<String> getCanonicalSessionNames() {
704 return getSessionNames(false);
708 public List<String> getBaseDomainNames() {
709 return new ArrayList<>(this.policyContainer.getKieContainer().getKieBaseNames());
713 * provides the underlying core layer container sessions.
715 * @return the attached Policy Container
717 protected List<PolicySession> getSessions() {
718 List<PolicySession> sessions = new ArrayList<>();
719 sessions.addAll(this.policyContainer.getPolicySessions());
724 * provides the underlying core layer container session with name sessionName.
726 * @param sessionName session name
727 * @return the attached Policy Container
728 * @throws IllegalArgumentException when an invalid session name is provided
729 * @throws IllegalStateException when the drools controller is in an invalid state
731 protected PolicySession getSession(String sessionName) {
732 if (sessionName == null || sessionName.isEmpty()) {
733 throw new IllegalArgumentException("A Session Name must be provided");
736 List<PolicySession> sessions = this.getSessions();
737 for (PolicySession session : sessions) {
738 if (sessionName.equals(session.getName()) || sessionName.equals(session.getFullName())) {
743 throw invalidSessNameEx(sessionName);
746 private IllegalArgumentException invalidSessNameEx(String sessionName) {
747 return new IllegalArgumentException("Invalid Session Name: " + sessionName);
751 public Map<String,Integer> factClassNames(String sessionName) {
752 validateSessionName(sessionName);
754 Map<String,Integer> classNames = new HashMap<>();
756 PolicySession session = getSession(sessionName);
757 KieSession kieSession = session.getKieSession();
759 Collection<FactHandle> facts = kieSession.getFactHandles();
760 for (FactHandle fact : facts) {
762 String className = kieSession.getObject(fact).getClass().getName();
763 if (classNames.containsKey(className)) {
764 classNames.put(className, classNames.get(className) + 1);
766 classNames.put(className, 1);
768 } catch (Exception e) {
769 logger.warn(FACT_RETRIEVE_ERROR, fact, e);
776 private void validateSessionName(String sessionName) {
777 if (sessionName == null || sessionName.isEmpty()) {
778 throw invalidSessNameEx(sessionName);
783 public long factCount(String sessionName) {
784 validateSessionName(sessionName);
786 PolicySession session = getSession(sessionName);
787 return session.getKieSession().getFactCount();
791 public List<Object> facts(String sessionName, String className, boolean delete) {
792 validateSessionName(sessionName);
794 if (className == null || className.isEmpty()) {
795 throw new IllegalArgumentException("Invalid Class Name: " + className);
799 ReflectionUtil.fetchClass(this.policyContainer.getClassLoader(), className);
800 if (factClass == null) {
801 throw new IllegalArgumentException("Class cannot be fetched in model's classloader: " + className);
804 PolicySession session = getSession(sessionName);
805 KieSession kieSession = session.getKieSession();
807 List<Object> factObjects = new ArrayList<>();
809 Collection<FactHandle> factHandles = kieSession.getFactHandles(new ClassObjectFilter(factClass));
810 for (FactHandle factHandle : factHandles) {
812 factObjects.add(kieSession.getObject(factHandle));
814 kieSession.delete(factHandle);
816 } catch (Exception e) {
817 logger.warn(FACT_RETRIEVE_ERROR, factHandle, e);
825 public <T> List<T> facts(@NonNull String sessionName, @NonNull Class<T> clazz) {
826 return facts(sessionName, clazz.getName(), false)
828 .filter(clazz::isInstance)
830 .collect(Collectors.toList());
834 public List<Object> factQuery(String sessionName, String queryName, String queriedEntity,
835 boolean delete, Object... queryParams) {
836 validateSessionName(sessionName);
838 if (queryName == null || queryName.isEmpty()) {
839 throw new IllegalArgumentException("Invalid Query Name: " + queryName);
842 if (queriedEntity == null || queriedEntity.isEmpty()) {
843 throw new IllegalArgumentException("Invalid Queried Entity: " + queriedEntity);
846 PolicySession session = getSession(sessionName);
847 KieSession kieSession = session.getKieSession();
849 validateQueryName(kieSession, queryName);
851 List<Object> factObjects = new ArrayList<>();
853 QueryResults queryResults = kieSession.getQueryResults(queryName, queryParams);
854 for (QueryResultsRow row : queryResults) {
856 factObjects.add(row.get(queriedEntity));
858 kieSession.delete(row.getFactHandle(queriedEntity));
860 } catch (Exception e) {
861 logger.warn("Object cannot be retrieved from row: {}", row, e);
868 private void validateQueryName(KieSession kieSession, String queryName) {
869 for (KiePackage kiePackage : kieSession.getKieBase().getKiePackages()) {
870 for (Query q : kiePackage.getQueries()) {
871 if (q.getName() != null && q.getName().equals(queryName)) {
877 throw new IllegalArgumentException("Invalid Query Name: " + queryName);
881 public <T> boolean delete(@NonNull String sessionName, @NonNull T fact) {
882 String factClassName = fact.getClass().getName();
884 PolicySession session = getSession(sessionName);
885 KieSession kieSession = session.getKieSession();
887 Collection<FactHandle> factHandles = kieSession.getFactHandles(new ClassObjectFilter(fact.getClass()));
888 for (FactHandle factHandle : factHandles) {
890 if (Objects.equals(fact, kieSession.getObject(factHandle))) {
891 logger.info("Deleting {} from {}", factClassName, sessionName);
892 kieSession.delete(factHandle);
895 } catch (Exception e) {
896 logger.warn(FACT_RETRIEVE_ERROR, factHandle, e);
903 public <T> boolean delete(@NonNull T fact) {
904 return this.getSessionNames().stream().map(ss -> delete(ss, fact)).reduce(false, Boolean::logicalOr);
908 public <T> boolean delete(@NonNull String sessionName, @NonNull Class<T> fact) {
909 PolicySession session = getSession(sessionName);
910 KieSession kieSession = session.getKieSession();
912 boolean success = true;
913 Collection<FactHandle> factHandles = kieSession.getFactHandles(new ClassObjectFilter(fact));
914 for (FactHandle factHandle : factHandles) {
916 kieSession.delete(factHandle);
917 } catch (Exception e) {
918 logger.warn(FACT_RETRIEVE_ERROR, factHandle, e);
926 public <T> boolean delete(@NonNull Class<T> fact) {
927 return this.getSessionNames().stream().map(ss -> delete(ss, fact)).reduce(false, Boolean::logicalOr);
932 public Class<?> fetchModelClass(String className) {
933 return ReflectionUtil.fetchClass(this.policyContainer.getClassLoader(), className);
937 * Get recent source events.
939 * @return the recentSourceEvents
942 public Object[] getRecentSourceEvents() {
943 synchronized (this.recentSourceEvents) {
944 Object[] events = new Object[recentSourceEvents.size()];
945 return recentSourceEvents.toArray(events);
950 * Get recent sink events.
952 * @return the recentSinkEvents
955 public String[] getRecentSinkEvents() {
956 synchronized (this.recentSinkEvents) {
957 String[] events = new String[recentSinkEvents.size()];
958 return recentSinkEvents.toArray(events);
963 public boolean isBrained() {
969 public String toString() {
970 StringBuilder builder = new StringBuilder();
972 .append("MavenDroolsController [policyContainer=")
973 .append(policyContainer.getName())
978 .append(", modelClassLoaderHash=")
979 .append(modelClassLoaderHash)
981 return builder.toString();
984 // these may be overridden by junit tests
986 protected EventProtocolCoder getCoderManager() {
987 return EventProtocolCoderConstants.getManager();
990 protected OrderedServiceImpl<DroolsControllerFeatureApi> getDroolsProviders() {
991 return DroolsControllerFeatureApiConstants.getProviders();
994 protected PolicyContainer makePolicyContainer(String groupId, String artifactId, String version) {
995 return new PolicyContainer(groupId, artifactId, version);
998 protected boolean isClass(String className) {
999 return ReflectionUtil.isClass(this.policyContainer.getClassLoader(), className);