protected void copyOrRemoveSnapshot(
String packageName, String snapshotName, boolean delete, String newSnapshotName)
throws SerializationException {
if (delete) {
log.info(
"USER:"******" REMOVING SNAPSHOT for package: ["
+ packageName
+ "] snapshot: ["
+ snapshotName
+ "]");
rulesRepository.removePackageSnapshot(packageName, snapshotName);
} else {
if (newSnapshotName.equals("")) {
throw new SerializationException("Need to have a new snapshot name.");
}
log.info(
"USER:"******" COPYING SNAPSHOT for package: ["
+ packageName
+ "] snapshot: ["
+ snapshotName
+ "] to ["
+ newSnapshotName
+ "]");
rulesRepository.copyPackageSnapshot(packageName, snapshotName, newSnapshotName);
}
}
private List<ProfileDefinition> loadFromDeprecatedRepository(RulesRepository repository) {
List<ProfileDefinition> result = new ArrayList<ProfileDefinition>();
for (int index = 0; index < repository.getProvidedProfiles().size(); index++) {
RulesProfile deprecated = (RulesProfile) repository.getProvidedProfiles().get(index);
DefaultProfileDefinition providedProfile =
DefaultProfileDefinition.create(deprecated.getName(), repository.getLanguage().getKey());
for (ActiveRule deprecatedActiveRule : deprecated.getActiveRules(true)) {
String repositoryKey = deprecatedActiveRule.getRepositoryKey();
if (StringUtils.isBlank(repositoryKey)) {
repositoryKey = getPluginKey(repository);
}
Rule rule = ruleFinder.findByKey(repositoryKey, deprecatedActiveRule.getRuleKey());
if (rule != null) {
ActiveRule activeRule =
providedProfile.activateRule(rule, deprecatedActiveRule.getSeverity());
for (ActiveRuleParam arp : deprecatedActiveRule.getActiveRuleParams()) {
activeRule.setParameter(arp.getKey(), arp.getValue());
}
}
}
result.add(providedProfile);
}
return result;
}
protected void removePackage(String uuid) {
try {
PackageItem item = rulesRepository.loadPackageByUUID(uuid);
log.info("USER:"******" REMOVEING package [" + item.getName() + "]");
item.remove();
rulesRepository.save();
} catch (RulesRepositoryException e) {
log.error("Unable to remove package.", e);
throw e;
}
}
public void savePackage(PackageConfigData data) throws SerializationException {
log.info("USER:"******" SAVING package [" + data.getName() + "]");
PackageItem item = rulesRepository.loadPackage(data.getName());
// If package is being unarchived.
boolean unarchived = (!data.isArchived() && item.isArchived());
Calendar packageLastModified = item.getLastModified();
DroolsHeader.updateDroolsHeader(data.getHeader(), item);
updateCategoryRules(data, item);
item.updateExternalURI(data.getExternalURI());
item.updateDescription(data.getDescription());
item.archiveItem(data.isArchived());
item.updateBinaryUpToDate(false);
if (!data.getFormat().equals("")) {
item.updateFormat(data.getFormat());
}
RuleBaseCache.getInstance().remove(data.getUuid());
item.checkin(data.getDescription());
// If package is archived, archive all the assets under it
if (data.isArchived()) {
handleArchivedForSavePackage(data, item);
} else if (unarchived) {
handleUnarchivedForSavePackage(data, item, packageLastModified);
}
}
private void updatePackageBinaries(PackageItem item, PackageAssembler packageAssembler)
throws DetailedSerializationException {
try {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutput out = new DroolsObjectOutputStream(bout);
out.writeObject(packageAssembler.getBinaryPackage());
item.updateCompiledPackage(new ByteArrayInputStream(bout.toByteArray()));
out.flush();
out.close();
item.updateBinaryUpToDate(true);
RuleBase ruleBase =
RuleBaseFactory.newRuleBase(new RuleBaseConfiguration(getClassLoaders(packageAssembler)));
ruleBase.addPackage(packageAssembler.getBinaryPackage());
rulesRepository.save();
} catch (Exception e) {
e.printStackTrace();
log.error(
"An error occurred building the package [" + item.getName() + "]: " + e.getMessage());
throw new DetailedSerializationException(
"An error occurred building the package.", e.getMessage());
}
}
protected String createPackage(String name, String description, String format, String[] workspace)
throws RulesRepositoryException {
log.info("USER: "******" CREATING package [" + name + "]");
PackageItem item = rulesRepository.createPackage(name, description, format, workspace);
return item.getUUID();
}
protected PackageConfigData[] listPackages(
boolean archive, String workspace, RepositoryFilter filter) {
List<PackageConfigData> result = new ArrayList<PackageConfigData>();
PackageIterator pkgs = rulesRepository.listPackages();
handleIteratePackages(archive, workspace, filter, result, pkgs);
sortPackages(result);
return result.toArray(new PackageConfigData[result.size()]);
}
/** To run this, need to hack the addRule method to not save a session */
@SuppressWarnings({"unused", "deprecation"})
private void setupData(RulesRepository repo) throws Exception {
int count = 1;
List<AssetItem> list = new ArrayList<AssetItem>();
String prefix = "HR/";
String cat = prefix + "CAT_1";
for (int i = 1; i <= NUM; i++) {
if (i % 500 == 0) {
repo.getSession().save();
for (Iterator<AssetItem> iter = list.iterator(); iter.hasNext(); ) {
AssetItem element = (AssetItem) iter.next();
element.getNode().checkin();
}
list.clear();
}
if (i > 2500) {
prefix = "FINANCE/";
}
if (count == 100) {
count = 1;
cat = prefix + "CAT_" + i;
System.err.println("changing CAT");
System.gc();
} else {
count++;
}
String ruleName = "rule_" + i + "_" + System.currentTimeMillis();
System.out.println("ADDING rule: " + ruleName);
AssetItem item =
repo.loadDefaultPackage().addAsset(ruleName, "Foo(bar == " + i + ")panic(" + i + ");");
item.addCategory(cat);
list.add(item);
}
}
private List<AssetItem> listACat(RulesRepository repo) {
long start = System.currentTimeMillis();
List<AssetItem> results = repo.findAssetsByCategory("HR/CAT_1", 0, -1).assets;
System.out.println("Time for listing a cat: " + (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
@SuppressWarnings("unused")
List<AssetItem> results2 = repo.findAssetsByCategory("HR/CAT_1", 0, -1).assets;
System.out.println("Time for listing a cat: " + (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
results2 = repo.findAssetsByCategory("HR/CAT_100", 0, -1).assets;
System.out.println("Time for listing a cat: " + (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
results2 = repo.findAssetsByCategory("HR/CAT_100", 0, -1).assets;
System.out.println("Time for listing a cat: " + (System.currentTimeMillis() - start));
return results;
}
protected void createPackageSnapshot(
String packageName, String snapshotName, boolean replaceExisting, String comment) {
log.info(
"USER:"******" CREATING PACKAGE SNAPSHOT for package: ["
+ packageName
+ "] snapshot name: ["
+ snapshotName);
if (replaceExisting) {
rulesRepository.removePackageSnapshot(packageName, snapshotName);
}
rulesRepository.createPackageSnapshot(packageName, snapshotName);
PackageItem item = rulesRepository.loadPackageSnapshot(packageName, snapshotName);
item.updateCheckinComment(comment);
rulesRepository.save();
}
protected PackageConfigData loadGlobalPackage() {
PackageItem item = rulesRepository.loadGlobalArea();
PackageConfigData data =
PackageConfigDataFactory.createPackageConfigDataWithOutDependencies(item);
if (data.isSnapshot()) {
data.setSnapshotName(item.getSnapshotName());
}
return data;
}
protected String renamePackage(String uuid, String newName) {
log.info(
"USER:"******" RENAMING package [UUID: "
+ uuid
+ "] to package ["
+ newName
+ "]");
return rulesRepository.renamePackage(uuid, newName);
}
protected byte[] exportPackages(String packageName) {
log.info("USER:"******" export package [name: " + packageName + "] ");
try {
return rulesRepository.dumpPackageFromRepositoryXml(packageName);
} catch (PathNotFoundException e) {
throw new RulesRepositoryException(e);
} catch (IOException e) {
throw new RulesRepositoryException(e);
} catch (RepositoryException e) {
throw new RulesRepositoryException(e);
}
}
protected String createSubPackage(String name, String description, String parentNode)
throws SerializationException {
log.info(
"USER: "******" CREATING subPackage ["
+ name
+ "], parent ["
+ parentNode
+ "]");
PackageItem item = rulesRepository.createSubPackage(name, description, parentNode);
return item.getUUID();
}
public ValidatedResponse validatePackageConfiguration(PackageConfigData data)
throws SerializationException {
log.info(
"USER:"******" validatePackageConfiguration package ["
+ data.getName()
+ "]");
RuleBaseCache.getInstance().remove(data.getUuid());
BRMSSuggestionCompletionLoader loader = createBRMSSuggestionCompletionLoader();
loader.getSuggestionEngine(rulesRepository.loadPackage(data.getName()), data.getHeader());
return validateBRMSSuggestionCompletionLoaderResponse(loader);
}
protected String[] listImagesInPackage(String packageName) throws SerializationException {
// load package
PackageItem item = rulesRepository.loadPackage(packageName);
List<String> retList = new ArrayList<String>();
Iterator<AssetItem> iter = item.getAssets();
while (iter.hasNext()) {
AssetItem pitem = iter.next();
if (pitem.getFormat().equalsIgnoreCase("png")
|| pitem.getFormat().equalsIgnoreCase("gif")
|| pitem.getFormat().equalsIgnoreCase("jpg")) {
retList.add(pitem.getName());
}
}
return (String[]) retList.toArray(new String[] {});
}
protected String copyPackage(String sourcePackageName, String destPackageName)
throws SerializationException {
try {
log.info(
"USER:"******" COPYING package ["
+ sourcePackageName
+ "] to package ["
+ destPackageName
+ "]");
return rulesRepository.copyPackage(sourcePackageName, destPackageName);
} catch (RulesRepositoryException e) {
log.error("Unable to copy package.", e);
throw e;
}
}
public BuilderResult buildPackage(
String packageUUID,
boolean force,
String buildMode,
String statusOperator,
String statusDescriptionValue,
boolean enableStatusSelector,
String categoryOperator,
String category,
boolean enableCategorySelector,
String customSelectorName)
throws SerializationException {
PackageItem item = rulesRepository.loadPackageByUUID(packageUUID);
try {
return buildPackage(
item,
force,
createConfiguration(
buildMode,
statusOperator,
statusDescriptionValue,
enableStatusSelector,
categoryOperator,
category,
enableCategorySelector,
customSelectorName));
} catch (NoClassDefFoundError e) {
throw new DetailedSerializationException(
"Unable to find a class that was needed when building the package ["
+ e.getMessage()
+ "]",
"Perhaps you are missing them from the model jars, or from the BRMS itself (lib directory).");
} catch (UnsupportedClassVersionError e) {
throw new DetailedSerializationException(
"Can not build the package. One or more of the classes that are needed were compiled with an unsupported Java version.",
"For example the pojo classes were compiled with Java 1.6 and Guvnor is running on Java 1.5. ["
+ e.getMessage()
+ "]");
}
}
protected String[] listRulesInPackage(String packageName) throws SerializationException {
// load package
PackageItem item = rulesRepository.loadPackage(packageName);
PackageDRLAssembler assembler = createPackageDRLAssembler(item);
List<String> result = new ArrayList<String>();
try {
String drl = assembler.getDRL();
if (drl == null || "".equals(drl)) {
return new String[0];
} else {
parseRulesToPackageList(assembler, result);
}
return result.toArray(new String[result.size()]);
} catch (DroolsParserException e) {
log.error("Unable to list rules in package", e);
return new String[0];
}
}
/** @deprecated in favour of {@link compareSnapshots(SnapshotComparisonPageRequest)} */
protected SnapshotDiffs compareSnapshots(
String packageName, String firstSnapshotName, String secondSnapshotName) {
SnapshotDiffs diffs = new SnapshotDiffs();
List<SnapshotDiff> list = new ArrayList<SnapshotDiff>();
PackageItem leftPackage = rulesRepository.loadPackageSnapshot(packageName, firstSnapshotName);
PackageItem rightPackage = rulesRepository.loadPackageSnapshot(packageName, secondSnapshotName);
// Older one has to be on the left.
if (isRightOlderThanLeft(leftPackage, rightPackage)) {
PackageItem temp = leftPackage;
leftPackage = rightPackage;
rightPackage = temp;
diffs.leftName = secondSnapshotName;
diffs.rightName = firstSnapshotName;
} else {
diffs.leftName = firstSnapshotName;
diffs.rightName = secondSnapshotName;
}
Iterator<AssetItem> leftExistingIter = leftPackage.getAssets();
while (leftExistingIter.hasNext()) {
AssetItem left = leftExistingIter.next();
if (isPackageItemDeleted(rightPackage, left)) {
SnapshotDiff diff = new SnapshotDiff();
diff.name = left.getName();
diff.diffType = SnapshotDiff.TYPE_DELETED;
diff.leftUuid = left.getUUID();
list.add(diff);
}
}
Iterator<AssetItem> rightExistingIter = rightPackage.getAssets();
while (rightExistingIter.hasNext()) {
AssetItem right = rightExistingIter.next();
AssetItem left = null;
if (right != null && leftPackage.containsAsset(right.getName())) {
left = leftPackage.loadAsset(right.getName());
}
// Asset is deleted or added
if (right == null || left == null) {
SnapshotDiff diff = new SnapshotDiff();
if (left == null) {
diff.name = right.getName();
diff.diffType = SnapshotDiff.TYPE_ADDED;
diff.rightUuid = right.getUUID();
}
list.add(diff);
} else if (isAssetArchivedOrRestored(right, left)) { // Has the asset
// been archived
// or restored
SnapshotDiff diff = new SnapshotDiff();
diff.name = right.getName();
diff.leftUuid = left.getUUID();
diff.rightUuid = right.getUUID();
if (left.isArchived()) {
diff.diffType = SnapshotDiff.TYPE_RESTORED;
} else {
diff.diffType = SnapshotDiff.TYPE_ARCHIVED;
}
list.add(diff);
} else if (isAssetItemUpdated(right, left)) { // Has the asset been
// updated
SnapshotDiff diff = new SnapshotDiff();
diff.name = right.getName();
diff.leftUuid = left.getUUID();
diff.rightUuid = right.getUUID();
diff.diffType = SnapshotDiff.TYPE_UPDATED;
list.add(diff);
}
}
diffs.diffs = list.toArray(new SnapshotDiff[list.size()]);
return diffs;
}
protected String buildPackageSource(String packageUUID) throws SerializationException {
PackageItem item = rulesRepository.loadPackageByUUID(packageUUID);
PackageDRLAssembler asm = new PackageDRLAssembler(item);
return asm.getDRL();
}
private String getCurrentUserName() {
return rulesRepository.getSession().getUserID();
}
// TODO: Not working. GUVNOR-475
protected void importPackages(byte[] byteArray, boolean importAsNew) {
rulesRepository.importPackageToRepository(byteArray, importAsNew);
}
