use of io.fabric8.api.PatchException in project fabric8 by jboss-fuse.
the class GitPatchManagementServiceImpl method alignTo.
@Override
public boolean alignTo(Map<String, String> versions, List<String> urls, File localMavenRepository, Runnable callback) throws PatchException {
if (aligning.getAndSet(true)) {
return false;
}
try {
if (!env.isFabric()) {
try {
// we probably survived fabric:create without refreshing patch-management bundle
env = envService.determineEnvironmentType();
File patchRepositoryLocation = new File(patchesDir, GitPatchRepositoryImpl.MAIN_GIT_REPO_LOCATION);
getGitPatchRepository().close();
GitPatchRepositoryImpl repository = new GitPatchRepositoryImpl(env, patchRepositoryLocation, karafHome, karafBase, karafData, patchesDir);
setGitPatchRepository(repository);
start();
// let's tweak the configuration when entering fabric mode
// this way we will track other kinds of baselines
ensurePatchManagementInitialized();
if (master) {
// let the caller know that we've configured patch management in "master" container
// this is mainly to push the changes from local to cluster git repository
// so child/ssh containers created in fabric can fetch correct baselines
callback.run();
}
} catch (Exception e) {
throw new PatchException(e.getMessage(), e);
}
}
if (env.isFabric()) {
Git fork = null;
try {
ensuringLock.lock();
String version = versions.get(env.getProductId());
String tagName = String.format(env.getBaselineTagFormat(), version);
// we have to be at that tag
Git mainRepository = gitPatchRepository.findOrCreateMainGitRepository();
fetchFabricPatchData(mainRepository);
fork = gitPatchRepository.cloneRepository(mainRepository, true);
gitPatchRepository.checkout(fork).setName(gitPatchRepository.getMainBranchName()).call();
RevTag tag = gitPatchRepository.findCurrentBaseline(fork);
if (tag != null && tagName.equals(tag.getTagName())) {
if (master) {
// and then to data/git/servlet
try {
gitPatchRepository.pushPatchBranches();
callback.run();
} catch (Exception e) {
Activator.log(LogService.LOG_WARNING, null, e.getMessage(), e, false);
} catch (Error e) {
// in case newer patch management calls agent which is still wired to old patch management
Activator.log(LogService.LOG_WARNING, null, e.getMessage(), e, false);
}
}
return false;
}
boolean baselineSwitched = handleNonCurrentBaseline(fork, version, tagName, false, true);
if (localMavenRepository != null) {
try {
File systemRepo = getSystemRepository(karafHome, systemContext);
// let's copy artifacts referenced in etc/startup.properties from localMavenRepository to system
File etcStartupProperties = new File(karafBase, "etc/startup.properties");
try (FileInputStream fis = new FileInputStream(etcStartupProperties)) {
Properties props = new Properties();
props.load(fis);
for (String artifact : props.stringPropertyNames()) {
File target = new File(systemRepo, artifact);
File src = new File(localMavenRepository, artifact);
if (!target.exists() && src.isFile()) {
FileUtils.copyFile(src, target);
}
}
}
// now the URLs from the passed lis
for (String url : urls) {
String path = Utils.mvnurlToPath(url);
if (path != null) {
File target = new File(systemRepo, path);
File src = new File(localMavenRepository, path);
if (!target.exists() && src.isFile()) {
FileUtils.copyFile(src, target);
}
}
}
} catch (Exception e) {
Activator.log(LogService.LOG_ERROR, null, e.getMessage(), e, false);
}
}
return baselineSwitched;
} catch (Exception e) {
throw new PatchException(e.getMessage(), e);
} finally {
ensuringLock.unlock();
if (fork != null) {
gitPatchRepository.closeRepository(fork, true);
}
}
}
return false;
} finally {
aligning.set(false);
}
}
use of io.fabric8.api.PatchException in project fabric8 by jboss-fuse.
the class GitPatchManagementServiceImpl method installProfiles.
@Override
public void installProfiles(File gitRepository, String versionId, Patch patch, ProfileUpdateStrategy strategy) {
// remember - we operate on totally different git repository!
// we should have version branch already checked out.
// here we don't merge/cherry-pick anything - we're preparing new commit simply by copying
// one set of profiles (from R patch) over another (current profile definitions from Fabric)
// we won't have merge conflicts, but we can't simply copy profiles over, because existing profiles
// may have custom changes
Git git = null;
try {
git = Git.open(gitRepository);
File src = new File(patch.getPatchData().getPatchDirectory(), "fabric/import/fabric/profiles");
File dst = new File(git.getRepository().getWorkTree(), "fabric/profiles");
// ENTESB-6003:
// let's clean the target directory first, so we can detect file removals in patches (like moving
// jmx.* and org.apache.karaf.command.* PIDs from jboss-fuse-full to acls profile)
FileUtils.deleteDirectory(dst);
dst.mkdir();
ProfileFileUtils.copyDirectory(src, dst, strategy);
git.add().addFilepattern(".").call();
// remove the deletes
for (String missing : git.status().call().getMissing()) {
git.rm().addFilepattern(missing).call();
}
// commit profile changes in patch branch - ultimate commit will be the merge commit
git.commit().setMessage("Installing profiles from patch \"" + patch.getPatchData().getId() + "\"").call();
PatchResult result = patch.getResult();
if (result == null) {
result = new PatchResult(patch.getPatchData(), false, new Date().getTime(), null, null);
patch.setResult(result);
}
result.getVersions().add(versionId);
result.store();
} catch (Exception e) {
throw new PatchException(e.getMessage(), e);
} finally {
if (git != null) {
gitPatchRepository.closeRepository(git, false);
}
}
}
use of io.fabric8.api.PatchException in project fabric8 by jboss-fuse.
the class GitPatchManagementServiceImpl method rollback.
@Override
public void rollback(PatchData patchData) {
Git fork = null;
try {
fork = gitPatchRepository.cloneRepository(gitPatchRepository.findOrCreateMainGitRepository(), true);
Ref installationBranch = null;
PatchKind kind = patchData.isRollupPatch() ? PatchKind.ROLLUP : PatchKind.NON_ROLLUP;
switch(kind) {
case ROLLUP:
{
Activator.log2(LogService.LOG_INFO, String.format("Rolling back rollup patch \"%s\"", patchData.getId()));
// rolling back a rollup patch should rebase all user commits on top of current baseline
// to previous baseline
RevTag currentBaseline = gitPatchRepository.findCurrentBaseline(fork);
RevCommit c1 = new RevWalk(fork.getRepository()).parseCommit(fork.getRepository().resolve(currentBaseline.getTagName() + "^{commit}"));
// remember the commit to discover P patch tags installed on top of rolledback baseline
RevCommit since = c1;
RevCommit c2 = new RevWalk(fork.getRepository()).parseCommit(fork.getRepository().resolve("HEAD"));
RevCommit to = c2;
Iterable<RevCommit> mainChangesSinceRollupPatch = fork.log().addRange(c1, c2).call();
List<RevCommit> userChanges = new LinkedList<>();
for (RevCommit rc : mainChangesSinceRollupPatch) {
if (isUserChangeCommit(rc)) {
userChanges.add(rc);
}
}
if (env == EnvType.STANDALONE) {
// remove the tag
fork.tagDelete().setTags(currentBaseline.getTagName()).call();
}
// baselines are stacked on each other
RevTag previousBaseline = gitPatchRepository.findNthPreviousBaseline(fork, env == EnvType.STANDALONE ? 0 : 1);
c1 = new RevWalk(fork.getRepository()).parseCommit(fork.getRepository().resolve(previousBaseline.getTagName() + "^{commit}"));
// hard reset of main patch branch - to point to other branch, originating from previous baseline
fork.reset().setMode(ResetCommand.ResetType.HARD).setRef(previousBaseline.getTagName() + "^{commit}").call();
// reapply those user changes that are not conflicting
ListIterator<RevCommit> it = userChanges.listIterator(userChanges.size());
Status status = fork.status().call();
if (!status.isClean()) {
// unstage any garbage
fork.reset().setMode(ResetCommand.ResetType.MIXED).call();
for (String p : status.getModified()) {
gitPatchRepository.checkout(fork).addPath(p).call();
}
}
while (it.hasPrevious()) {
RevCommit userChange = it.previous();
CherryPickResult cpr = fork.cherryPick().include(userChange.getId()).setNoCommit(true).call();
// this time prefer user change on top of previous baseline - this change shouldn't be
// conflicting, because when rolling back, patch change was preferred over user change
handleCherryPickConflict(patchData.getPatchDirectory(), fork, cpr, userChange, true, PatchKind.ROLLUP, null, false, true);
// restore backed up content from the reapplied user change
String[] commitMessage = userChange.getFullMessage().split("\n\n");
if (commitMessage.length > 1) {
// we have original commit (that had conflicts) stored in this commit's full message
String ref = commitMessage[commitMessage.length - 1];
File backupDir = new File(patchesDir, patchData.getId() + ".backup");
if (isStandaloneChild()) {
backupDir = new File(patchesDir, patchData.getId() + "." + System.getProperty("karaf.name") + ".backup");
}
backupDir = new File(backupDir, ref);
if (backupDir.exists() && backupDir.isDirectory()) {
Activator.log2(LogService.LOG_DEBUG, String.format("Restoring content of %s", backupDir.getCanonicalPath()));
copyManagedDirectories(backupDir, karafBase, false, false, false);
}
}
gitPatchRepository.prepareCommit(fork, userChange.getFullMessage()).call();
}
gitPatchRepository.push(fork);
if (env == EnvType.STANDALONE) {
// remove remote tag
fork.push().setRefSpecs(new RefSpec().setSource(null).setDestination("refs/tags/" + currentBaseline.getTagName())).call();
}
// remove tags related to non-rollup patches installed between
// rolled back baseline and previous HEAD, because rolling back to previous rollup patch
// (previous baseline) equal effectively to starting from fresh baseline
RevWalk walk = new RevWalk(fork.getRepository());
Map<String, RevTag> tags = gitPatchRepository.findTagsBetween(fork, since, to);
for (Map.Entry<String, RevTag> entry : tags.entrySet()) {
if (entry.getKey().startsWith("patch-")) {
fork.tagDelete().setTags(entry.getKey()).call();
fork.push().setRefSpecs(new RefSpec().setSource(null).setDestination("refs/tags/" + entry.getKey())).call();
}
}
// HEAD of main patch branch after reset and cherry-picks
c2 = new RevWalk(fork.getRepository()).parseCommit(fork.getRepository().resolve("HEAD"));
// applyChanges(fork, c1, c2);
applyChanges(fork, false);
break;
}
case NON_ROLLUP:
{
Activator.log2(LogService.LOG_INFO, String.format("Rolling back non-rollup patch \"%s\"", patchData.getId()));
// rolling back a non-rollup patch is a revert of the patch commit and removal of patch tag
String patchTagName = String.format("patch-%s", env == EnvType.STANDALONE ? patchData.getId() : patchData.getId() + "-" + gitPatchRepository.getStandaloneChildkarafName());
ObjectId oid = fork.getRepository().resolve(patchTagName);
if (oid == null) {
throw new PatchException(String.format("Can't find installed patch (tag %s is missing)", patchTagName));
}
RevCommit commit = new RevWalk(fork.getRepository()).parseCommit(oid);
RevertCommand revertCommand = fork.revert().include(commit);
RevCommit reverted = revertCommand.call();
if (reverted == null) {
List<String> unmerged = revertCommand.getUnmergedPaths();
Activator.log2(LogService.LOG_WARNING, "Problem rolling back patch \"" + patchData.getId() + "\". The following files where updated later:");
for (String path : unmerged) {
Activator.log2(LogService.LOG_WARNING, " - " + path);
}
RevWalk walk = new RevWalk(fork.getRepository());
RevCommit head = walk.parseCommit(fork.getRepository().resolve("HEAD"));
Map<String, RevTag> tags = gitPatchRepository.findTagsBetween(fork, commit, head);
List<RevTag> laterPatches = new LinkedList<>();
if (tags.size() > 0) {
for (Map.Entry<String, RevTag> tag : tags.entrySet()) {
if (tag.getKey().startsWith("patch-")) {
laterPatches.add(tag.getValue());
}
}
Activator.log2(LogService.LOG_INFO, "The following patches were installed after \"" + patchData.getId() + "\":");
for (RevTag t : laterPatches) {
String message = " - " + t.getTagName().substring("patch-".length());
RevObject object = walk.peel(t);
if (object != null) {
RevCommit c = walk.parseCommit(object.getId());
String date = GitPatchRepository.FULL_DATE.format(new Date(c.getCommitTime() * 1000L));
message += " (" + date + ")";
}
Activator.log2(LogService.LOG_INFO, message);
}
}
return;
}
// TODO: should we restore the backup possibly created when instalilng P patch?
// remove the tag
fork.tagDelete().setTags(patchTagName).call();
gitPatchRepository.push(fork);
// remove remote tag
fork.push().setRefSpecs(new RefSpec().setSource(null).setDestination(String.format("refs/tags/%s", patchTagName))).call();
// HEAD of main patch branch after reset and cherry-picks
RevCommit c = new RevWalk(fork.getRepository()).parseCommit(fork.getRepository().resolve("HEAD"));
applyChanges(fork, c.getParent(0), c);
break;
}
}
} catch (IOException | GitAPIException e) {
throw new PatchException(e.getMessage(), e);
} finally {
if (fork != null) {
gitPatchRepository.closeRepository(fork, true);
}
}
}
use of io.fabric8.api.PatchException in project fabric8 by jboss-fuse.
the class GitPatchManagementServiceImpl method fetchPatches.
@Override
public List<PatchData> fetchPatches(URL url) throws PatchException {
try {
List<PatchData> patches = new ArrayList<>(1);
File patchFile = new File(patchesDir, Long.toString(System.currentTimeMillis()) + ".patch.tmp");
InputStream input = url.openStream();
FileOutputStream output = new FileOutputStream(patchFile);
ZipFile zf = null;
try {
IOUtils.copy(input, output);
} finally {
IOUtils.closeQuietly(input);
IOUtils.closeQuietly(output);
}
try {
zf = new ZipFile(patchFile);
} catch (IOException ignored) {
if (!FilenameUtils.getExtension(url.getFile()).equals("patch")) {
throw new PatchException("Patch should be ZIP file or *.patch descriptor");
}
}
// patchFile may "be" a patch descriptor or be a ZIP file containing descriptor
PatchData patchData = null;
// in case patch ZIP file has no descriptor, we'll "generate" patch data on the fly
// no descriptor -> assume we have rollup patch or even full, new distribution
PatchData fallbackPatchData = new PatchData(FilenameUtils.getBaseName(url.getPath()));
fallbackPatchData.setGenerated(true);
fallbackPatchData.setRollupPatch(true);
fallbackPatchData.setPatchDirectory(new File(patchesDir, fallbackPatchData.getId()));
fallbackPatchData.setPatchLocation(patchesDir);
if (zf != null) {
File systemRepo = getSystemRepository(karafHome, systemContext);
try {
List<ZipArchiveEntry> otherResources = new LinkedList<>();
boolean skipRootDir = false;
for (Enumeration<ZipArchiveEntry> e = zf.getEntries(); e.hasMoreElements(); ) {
ZipArchiveEntry entry = e.nextElement();
if (!skipRootDir && entry.isDirectory() && (entry.getName().startsWith("jboss-fuse-") || entry.getName().startsWith("jboss-a-mq-"))) {
skipRootDir = true;
}
if (entry.isDirectory() || entry.isUnixSymlink()) {
continue;
}
String name = entry.getName();
if (skipRootDir) {
name = name.substring(name.indexOf('/') + 1);
}
if (!name.contains("/") && name.endsWith(".patch")) {
// patch descriptor in ZIP's root directory
if (patchData == null) {
// load data from patch descriptor inside ZIP. This may or may not be a rollup
// patch
File target = new File(patchesDir, name);
extractZipEntry(zf, entry, target);
patchData = loadPatchData(target);
// ENTESB-4600: try checking the target version of the patch
Version version = Utils.findVersionInName(patchData.getId());
if (version.getMajor() == 6 && version.getMinor() == 1) {
throw new PatchException("Can't install patch \"" + patchData.getId() + "\", it is released for version 6.1 of the product");
}
patchData.setGenerated(false);
File targetDirForPatchResources = new File(patchesDir, patchData.getId());
patchData.setPatchDirectory(targetDirForPatchResources);
patchData.setPatchLocation(patchesDir);
target.renameTo(new File(patchesDir, patchData.getId() + ".patch"));
patches.add(patchData);
} else {
throw new PatchException(String.format("Multiple patch descriptors: already have patch %s and now encountered entry %s", patchData.getId(), name));
}
} else {
File target = null;
String relativeName = null;
if (name.startsWith("system/")) {
// copy to ${karaf.default.repository}
relativeName = name.substring("system/".length());
target = new File(systemRepo, relativeName);
} else if (name.startsWith("repository/")) {
// copy to ${karaf.default.repository}
relativeName = name.substring("repository/".length());
target = new File(systemRepo, relativeName);
} else {
// other files that should be applied to ${karaf.home} when the patch is installed
otherResources.add(entry);
}
if (target != null) {
// we unzip to system repository
extractAndTrackZipEntry(fallbackPatchData, zf, entry, target, skipRootDir);
}
}
}
File targetDirForPatchResources = new File(patchesDir, patchData == null ? fallbackPatchData.getId() : patchData.getId());
// now copy non-maven resources (we should now know where to copy them)
for (ZipArchiveEntry entry : otherResources) {
String name = entry.getName();
if (skipRootDir) {
name = name.substring(name.indexOf('/'));
}
File target = new File(targetDirForPatchResources, name);
extractAndTrackZipEntry(fallbackPatchData, zf, entry, target, skipRootDir);
}
} finally {
if (zf != null) {
zf.close();
}
if (patchFile != null) {
patchFile.delete();
}
}
} else {
// If the file is not a zip/jar, assume it's a single patch file
patchData = loadPatchData(patchFile);
// no patch directory - no attached content, assuming only references to bundles
patchData.setPatchDirectory(null);
patchFile.renameTo(new File(patchesDir, patchData.getId() + ".patch"));
patches.add(patchData);
}
if (patches.size() == 0) {
// let's use generated patch descriptor
File generatedPatchDescriptor = new File(patchesDir, fallbackPatchData.getId() + ".patch");
FileOutputStream out = new FileOutputStream(generatedPatchDescriptor);
try {
fallbackPatchData.storeTo(out);
} finally {
IOUtils.closeQuietly(out);
}
patches.add(fallbackPatchData);
}
return patches;
} catch (IOException e) {
throw new PatchException("Unable to download patch from url " + url, e);
}
}
use of io.fabric8.api.PatchException in project fabric8 by jboss-fuse.
the class ServiceImpl method featureUpdatesInPatch.
/**
* Returns a list of {@link FeatureUpdate} for single patch, taking into account already discovered updates
* @param patch
* @param updatesForFeatureKeys
* @param kind
* @return
*/
private List<FeatureUpdate> featureUpdatesInPatch(Patch patch, Map<String, FeatureUpdate> updatesForFeatureKeys, PatchKind kind) throws Exception {
Set<String> addedRepositoryNames = new HashSet<>();
HashMap<String, Repository> after = null;
try {
List<FeatureUpdate> updatesInThisPatch = new LinkedList<>();
/*
* Two pairs of features makes feature names not enough to be a key:
* <feature name="openjpa" description="Apache OpenJPA 2.2.x persistent engine support" version="2.2.2" resolver="(obr)">
* <feature name="openjpa" description="Apache OpenJPA 2.3.x persistence engine support" version="2.3.0" resolver="(obr)">
* and
* <feature name="activemq-camel" version="5.11.0.redhat-621039" resolver="(obr)" start-level="50">
* <feature name="activemq-camel" version="1.2.0.redhat-621039" resolver="(obr)">
*/
// install the new feature repos, tracking the set the were
// installed before and after
// (e.g, "karaf-enterprise-2.4.0.redhat-620133" -> Repository)
Map<String, Repository> before = new HashMap<>(getAvailableFeatureRepositories());
for (String url : patch.getPatchData().getFeatureFiles()) {
featuresService.addRepository(new URI(url));
}
after = getAvailableFeatureRepositories();
// track which old repos provide which features to find out if we have new repositories for those features
// key is name|version (don't expect '|' to be part of name...)
// assume that [feature-name, feature-version{major,minor,0,0}] is defined only in single repository
Map<String, String> featuresInOldRepositories = new HashMap<>();
// key is only name, without version - used when there's single feature in old and in new repositories
MultiMap<String, String> singleFeaturesInOldRepositories = new MultiMap<>();
Map<String, Version> actualOldFeatureVersions = new HashMap<>();
for (Repository existingRepository : before.values()) {
for (Feature feature : existingRepository.getFeatures()) {
Version v = Utils.getOsgiVersion(feature.getVersion());
Version lowestUpdateableVersion = new Version(v.getMajor(), v.getMinor(), 0);
// assume that we can update feature XXX-2.2.3 to XXX-2.2.142, but not to XXX-2.3.0.alpha-1
String key = String.format("%s|%s", feature.getName(), lowestUpdateableVersion.toString());
featuresInOldRepositories.put(key, existingRepository.getURI().toString());
singleFeaturesInOldRepositories.put(feature.getName(), existingRepository.getURI().toString());
actualOldFeatureVersions.put(key, v);
}
}
// Use the before and after set to figure out which repos were added.
addedRepositoryNames = new HashSet<>(after.keySet());
addedRepositoryNames.removeAll(before.keySet());
// track the new repositories where we can find old features
Map<String, String> featuresInNewRepositories = new HashMap<>();
MultiMap<String, String> singleFeaturesInNewRepositories = new MultiMap<>();
Map<String, String> actualNewFeatureVersions = new HashMap<>();
MultiMap<String, String> singleActualNewFeatureVersions = new MultiMap<>();
// Figure out which old repos were updated: Do they have feature
// with the same name as one contained in a repo being added?
// and do they have update'able version? (just like with bundles)
Set<String> oldRepositoryNames = new HashSet<String>();
for (String addedRepositoryName : addedRepositoryNames) {
Repository added = after.get(addedRepositoryName);
for (Feature feature : added.getFeatures()) {
Version v = Utils.getOsgiVersion(feature.getVersion());
Version lowestUpdateableVersion = new Version(v.getMajor(), v.getMinor(), 0);
String key = String.format("%s|%s", feature.getName(), lowestUpdateableVersion.toString());
featuresInNewRepositories.put(key, addedRepositoryName);
singleFeaturesInNewRepositories.put(feature.getName(), addedRepositoryName);
actualNewFeatureVersions.put(key, v.toString());
singleActualNewFeatureVersions.put(feature.getName(), v.toString());
String oldRepositoryWithUpdateableFeature = featuresInOldRepositories.get(key);
if (oldRepositoryWithUpdateableFeature == null && singleFeaturesInOldRepositories.get(feature.getName()) != null && singleFeaturesInOldRepositories.get(feature.getName()).size() == 1) {
oldRepositoryWithUpdateableFeature = singleFeaturesInOldRepositories.get(feature.getName()).get(0);
}
if (oldRepositoryWithUpdateableFeature != null) {
// track the old repository to be removed
oldRepositoryNames.add(oldRepositoryWithUpdateableFeature);
}
}
}
// We need to uninstall them. Before we uninstall, track which features were installed.
for (String oldRepositoryName : oldRepositoryNames) {
Repository repository = before.get(oldRepositoryName);
for (Feature feature : repository.getFeatures()) {
if (featuresService.isInstalled(feature)) {
Version v = Utils.getOsgiVersion(feature.getVersion());
Version lowestUpdateableVersion = new Version(v.getMajor(), v.getMinor(), 0);
String key = String.format("%s|%s", feature.getName(), lowestUpdateableVersion.toString());
String newRepositoryName = featuresInNewRepositories.get(key);
String newVersion = actualNewFeatureVersions.get(key);
if (newRepositoryName == null) {
// feature from 1.1.1 to 1.3.0
if (singleFeaturesInOldRepositories.get(feature.getName()) != null && singleFeaturesInOldRepositories.get(feature.getName()).size() == 1 && singleFeaturesInNewRepositories.get(feature.getName()) != null && singleFeaturesInNewRepositories.get(feature.getName()).size() == 1) {
newRepositoryName = singleFeaturesInNewRepositories.get(feature.getName()).get(0);
}
}
if (newVersion == null) {
if (singleActualNewFeatureVersions.get(feature.getName()) != null && singleActualNewFeatureVersions.get(feature.getName()).size() == 1) {
newVersion = singleActualNewFeatureVersions.get(feature.getName()).get(0);
}
}
FeatureUpdate featureUpdate = null;
if (newVersion != null && newRepositoryName != null) {
featureUpdate = new FeatureUpdate(feature.getName(), after.get(oldRepositoryName).getURI().toString(), feature.getVersion(), after.get(newRepositoryName).getURI().toString(), newVersion);
} else {
// we didn't find an update for installed features among feature repositories from patch
// which means we have to preserve both the feature and the repository - this may
// be user's feature
featureUpdate = new FeatureUpdate(feature.getName(), after.get(oldRepositoryName).getURI().toString(), feature.getVersion(), null, null);
}
updatesInThisPatch.add(featureUpdate);
// Merge result
FeatureUpdate oldUpdate = updatesForFeatureKeys.get(key);
if (oldUpdate != null) {
Version upv = null, newV = null;
if (oldUpdate.getNewVersion() != null) {
upv = VersionTable.getVersion(oldUpdate.getNewVersion());
}
if (newVersion != null) {
newV = VersionTable.getVersion(newVersion);
}
if (upv == null && newV == null) {
// weird...
} else {
if (upv == null || (newV != null && upv.compareTo(newV) < 0)) {
// other patch contains newer update for the feature
updatesForFeatureKeys.put(key, featureUpdate);
}
}
} else {
// this is the first update of the bundle
updatesForFeatureKeys.put(key, featureUpdate);
}
}
}
}
// now let's see if there are repositories that are NOT updated (either they're not available in patch
// (like user feature repositories) or simply didn't change (like jclouds 1.8.1 between Fuse 6.2 and 6.2.1)
Set<String> unchangedRepositoryNames = new HashSet<>(before.keySet());
unchangedRepositoryNames.removeAll(oldRepositoryNames);
for (String unchangedRepositoryName : unchangedRepositoryNames) {
Repository repository = before.get(unchangedRepositoryName);
boolean hasInstalledFeatures = false;
for (Feature feature : repository.getFeatures()) {
if (featuresService.isInstalled(feature)) {
FeatureUpdate featureUpdate = new FeatureUpdate(feature.getName(), after.get(unchangedRepositoryName).getURI().toString(), feature.getVersion(), null, null);
hasInstalledFeatures = true;
// preserve unchanged/user feature - install after restart
updatesInThisPatch.add(featureUpdate);
// the key doesn't matter
updatesForFeatureKeys.put(String.format("%s|%s", feature.getName(), feature.getVersion()), featureUpdate);
}
}
if (!hasInstalledFeatures) {
// we have to preserve unchanged/user feature repository - even if it had no installed features
// this featureUpdate means - "restore feature repository only"
FeatureUpdate featureUpdate = new FeatureUpdate(null, after.get(unchangedRepositoryName).getURI().toString(), null, null, null);
updatesInThisPatch.add(featureUpdate);
updatesForFeatureKeys.put(String.format("REPOSITORY_TO_ADD:%s", after.get(unchangedRepositoryName).getURI().toString()), featureUpdate);
}
}
return updatesInThisPatch;
} catch (Exception e) {
throw new PatchException(e.getMessage(), e);
} finally {
// we'll add new feature repositories again later. here we've added them only to track the updates
if (after != null) {
for (String repo : addedRepositoryNames) {
if (after.get(repo) != null) {
featuresService.removeRepository(after.get(repo).getURI(), false);
}
}
}
}
}
Aggregations