private KieSessionModel findKieSessionModel(boolean stateless) {
KieSessionModel defaultKieSessionModel =
stateless ? kProject.getDefaultStatelessKieSession() : kProject.getDefaultKieSession();
if (defaultKieSessionModel == null) {
throw new RuntimeException(
stateless
? "Cannot find a default StatelessKieSession"
: "Cannot find a default KieSession");
}
return defaultKieSessionModel;
}
private boolean isFileInKBase(
InternalKieModule kieModule, KieBaseModel kieBase, String fileName) {
if (filterFileInKBase(kieModule, kieBase, fileName)) {
return true;
}
for (String include : kProject.getTransitiveIncludes(kieBase)) {
InternalKieModule includeModule = kProject.getKieModuleForKBase(include);
if (includeModule != null
&& filterFileInKBase(includeModule, kProject.getKieBaseModel(include), fileName)) {
return true;
}
}
return false;
}
public StatelessKieSession newStatelessKieSession(
String kSessionName, KieSessionConfiguration conf) {
KieSessionModelImpl kSessionModel =
(KieSessionModelImpl) kProject.getKieSessionModel(kSessionName);
if (kSessionModel == null) {
log.error("Unknown KieSession name: " + kSessionName);
return null;
}
if (kSessionModel.getType() == KieSessionModel.KieSessionType.STATEFUL) {
throw new RuntimeException(
"Trying to create a stateless KieSession from a stateful KieSessionModel: "
+ kSessionName);
}
KieBase kBase = getKieBase(kSessionModel.getKieBaseModel().getName());
if (kBase == null) {
log.error("Unknown KieBase name: " + kSessionModel.getKieBaseModel().getName());
return null;
}
StatelessKieSession statelessKieSession =
kBase.newStatelessKieSession(
conf != null ? conf : getKnowledgeSessionConfiguration(kSessionModel));
wireListnersAndWIHs(kSessionModel, statelessKieSession);
registerLoggers(kSessionModel, statelessKieSession);
statelessKSessions.put(kSessionName, statelessKieSession);
return statelessKieSession;
}
private KieBaseModelImpl getKieBaseModelImpl(String kBaseName) {
KieBaseModelImpl kBaseModel = (KieBaseModelImpl) kProject.getKieBaseModel(kBaseName);
if (kBaseModel == null) {
throw new RuntimeException("The requested KieBase \"" + kBaseName + "\" does not exist");
}
return kBaseModel;
}
public KieBase getKieBase() {
KieBaseModel defaultKieBaseModel = kProject.getDefaultKieBaseModel();
if (defaultKieBaseModel == null) {
throw new RuntimeException("Cannot find a default KieBase");
}
return getKieBase(defaultKieBaseModel.getName());
}
public KieBase newKieBase(KieBaseConfiguration conf) {
KieBaseModel defaultKieBaseModel = kProject.getDefaultKieBaseModel();
if (defaultKieBaseModel == null) {
throw new RuntimeException("Cannot find a default KieBase");
}
return newKieBase(defaultKieBaseModel.getName(), conf);
}
private KieBase createKieBase(
KieBaseModelImpl kBaseModel,
KieProject kieProject,
ResultsImpl messages,
KieBaseConfiguration conf) {
ClassLoader cl = kieProject.getClassLoader();
InternalKieModule kModule = kieProject.getKieModuleForKBase(kBaseModel.getName());
Collection<KnowledgePackage> pkgs =
kModule.getKnowledgePackagesForKieBase(kBaseModel.getName());
if (pkgs == null) {
KnowledgeBuilder kbuilder = buildKnowledgePackages(kBaseModel, kieProject, messages);
if (kbuilder.hasErrors()) {
// Messages already populated by the buildKnowlegePackages
return null;
}
}
// if we get to here, then we know the pkgs is now cached
pkgs = kModule.getKnowledgePackagesForKieBase(kBaseModel.getName());
if (kBaseModel.getEventProcessingMode() == EventProcessingOption.CLOUD
&& (conf == null
|| conf.getOption(EventProcessingOption.class) == EventProcessingOption.CLOUD)) {
for (KnowledgePackage kpkg : pkgs) {
if (((KnowledgePackageImpl) kpkg).needsStreamMode()) {
throw new RuntimeException(
"The requested KieBase \""
+ kBaseModel.getName()
+ "\" has been set to run in CLOUD mode but requires features only available in STREAM mode");
}
}
}
if (conf == null) {
conf = getKnowledgeBaseConfiguration(kBaseModel, cl);
} else if (conf instanceof RuleBaseConfiguration) {
((RuleBaseConfiguration) conf).setClassLoader(cl);
}
InternalKnowledgeBase kBase =
(InternalKnowledgeBase) KnowledgeBaseFactory.newKnowledgeBase(conf);
kBase.addKnowledgePackages(pkgs);
return kBase;
}
public KieBaseModel getKieBaseModel(String kBaseName) {
return kProject.getKieBaseModel(kBaseName);
}
public KieModule getKieModuleForKBase(String kBaseName) {
return kProject.getKieModuleForKBase(kBaseName);
}
public InputStream getPomAsStream() {
return kProject.getPomAsStream();
}
public Collection<String> getKieSessionNamesInKieBase(String kBaseName) {
KieBaseModel kieBaseModel = kProject.getKieBaseModel(kBaseName);
return kieBaseModel != null
? kieBaseModel.getKieSessionModels().keySet()
: Collections.<String>emptySet();
}
public Collection<String> getKieBaseNames() {
return kProject.getKieBaseNames();
}
private Results update(final InternalKieModule currentKM, final ReleaseId newReleaseId) {
final InternalKieModule newKM = (InternalKieModule) kr.getKieModule(newReleaseId);
ChangeSetBuilder csb = new ChangeSetBuilder();
final KieJarChangeSet cs = csb.build(currentKM, newKM);
final List<String> modifiedClasses = getModifiedClasses(cs);
final List<String> dslFiles = getUnchangedDslFiles(newKM, cs);
((KieModuleKieProject) kProject).updateToModule(newKM);
final ResultsImpl results = new ResultsImpl();
List<String> kbasesToRemove = new ArrayList<String>();
for (Entry<String, KieBase> kBaseEntry : kBases.entrySet()) {
String kbaseName = kBaseEntry.getKey();
final KieBaseModel kieBaseModel = kProject.getKieBaseModel(kbaseName);
// if a kbase no longer exists, just remove it from the cache
if (kieBaseModel == null) {
// have to save for later removal to avoid iteration errors
kbasesToRemove.add(kbaseName);
} else {
final InternalKnowledgeBase kBase = (InternalKnowledgeBase) kBaseEntry.getValue();
boolean locked = kBase.tryLock();
if (locked) {
try {
updateKBase(
kBase,
currentKM,
newReleaseId,
newKM,
cs,
modifiedClasses,
dslFiles,
results,
kieBaseModel);
} finally {
kBase.unlock();
}
} else {
kBase.enqueueModification(
new Runnable() {
@Override
public void run() {
updateKBase(
kBase,
currentKM,
newReleaseId,
newKM,
cs,
modifiedClasses,
dslFiles,
results,
kieBaseModel);
}
});
}
}
}
for (String kbaseToRemove : kbasesToRemove) {
kBases.remove(kbaseToRemove);
}
for (Iterator<Entry<String, KieSession>> it = this.kSessions.entrySet().iterator();
it.hasNext(); ) {
Entry<String, KieSession> ksession = it.next();
if (kProject.getKieSessionModel(ksession.getKey()) == null) {
// remove sessions that no longer exist
it.remove();
}
}
for (Iterator<Entry<String, StatelessKieSession>> it =
this.statelessKSessions.entrySet().iterator();
it.hasNext(); ) {
Entry<String, StatelessKieSession> ksession = it.next();
if (kProject.getKieSessionModel(ksession.getKey()) == null) {
// remove sessions that no longer exist
it.remove();
}
}
return results;
}
public long getCreationTimestamp() {
return kProject.getCreationTimestamp();
}
public KieSessionModel getKieSessionModel(String kSessionName) {
return kProject.getKieSessionModel(kSessionName);
}
public KieContainerImpl(KieProject kProject, KieRepository kr) {
this.kr = kr;
this.kProject = kProject;
kProject.init();
}
public ReleaseId getReleaseId() {
return kProject.getGAV();
}
