/** * @param projectId * @param changePackage * @param projectHistory * @param newVersion * @param newProjectState * @throws FatalESException */ private void trySave( ProjectId projectId, AbstractChangePackage changePackage, final ProjectHistory projectHistory, Version newVersion, final Project newProjectState) throws FatalESException { getResourceHelper() .createResourceForProject( newProjectState, newVersion.getPrimarySpec(), projectHistory.getProjectId()); getResourceHelper() .createResourceForChangePackage(changePackage, newVersion.getPrimarySpec(), projectId); if (FileBasedChangePackage.class.isInstance(changePackage)) { try { /* move the temporary file to the project folder */ final URI uri = changePackage.eResource().getURI(); final URI normalizedUri = changePackage.eResource().getResourceSet().getURIConverter().normalize(uri); final String filePath = normalizedUri.toFileString() + ".1"; // $NON-NLS-1$ FileBasedChangePackage.class.cast(changePackage).move(filePath); ModelUtil.saveResource(changePackage.eResource(), ModelUtil.getResourceLogger()); } catch (final IOException ex) { throw new FatalESException(StorageException.NOSAVE, ex); } } getResourceHelper().createResourceForVersion(newVersion, projectHistory.getProjectId()); newVersion.setProjectStateResource(newProjectState.eResource()); newVersion.setChangeResource(changePackage.eResource()); }
private PrimaryVersionSpec resolvePagedUpdateVersionSpec( ProjectHistory projectHistory, PagedUpdateVersionSpec baseVersion) { int changes = 0; PrimaryVersionSpec resolvedSpec = baseVersion.getBaseVersionSpec(); int maxChanges = baseVersion.getMaxChanges(); int i = resolvedSpec.getIdentifier(); AbstractChangePackage cp = projectHistory.getVersions().get(i).getChanges(); if (i == projectHistory.getVersions().size() - 1) { return projectHistory.getVersions().get(i).getPrimarySpec(); } do { cp = projectHistory.getVersions().get(++i).getChanges(); } while (cp == null && i < projectHistory.getVersions().size()); // pull at least one change package if (cp.leafSize() > maxChanges) { maxChanges = cp.leafSize(); } while (changes < maxChanges && i < projectHistory.getVersions().size()) { resolvedSpec = projectHistory.getVersions().get(i).getPrimarySpec(); final Version version = projectHistory.getVersions().get(i); final AbstractChangePackage changePackage = version.getChanges(); if (changePackage != null) { final int size = changePackage.leafSize(); if (changes + size >= maxChanges) { resolvedSpec = projectHistory.getVersions().get(i).getPrimarySpec(); break; } changes += size; } i += 1; } return resolvedSpec; }
/** * Returns all changes within the specified version range for a given project. * * @param projectId the ID of a project * @param source the source version * @param target the target version (inclusive) * @return a list of change packages containing all the changes for the specified version range * @throws InvalidVersionSpecException if an invalid version has been specified * @throws ESException in case of failure */ @ESMethod(MethodId.GETCHANGES) public List<AbstractChangePackage> getChanges( ProjectId projectId, VersionSpec source, VersionSpec target) throws InvalidVersionSpecException, ESException { sanityCheckObjects(projectId, source, target); final PrimaryVersionSpec resolvedSource = resolveVersionSpec(projectId, source); final PrimaryVersionSpec resolvedTarget = resolveVersionSpec(projectId, target); // if target and source are equal return empty list if (resolvedSource.getIdentifier() == resolvedTarget.getIdentifier()) { return new ArrayList<AbstractChangePackage>(); } synchronized (getMonitor()) { final boolean updateForward = resolvedTarget.getIdentifier() > resolvedSource.getIdentifier(); // Example: if you want the changes to get from version 5 to 7, you // need the changes contained in version 6 // and 7. The reason is that each version holds the changes which // occurred from the predecessor to the // version itself. Version 5 holds the changes to get from version 4 // to 5 and therefore is irrelevant. // For that reason the first version is removed, since getVersions // always sorts ascending order. final List<Version> versions = getVersions(projectId, resolvedSource, resolvedTarget); if (versions.size() > 1) { versions.remove(0); } List<AbstractChangePackage> result = new ArrayList<AbstractChangePackage>(); for (final Version version : versions) { final AbstractChangePackage changes = version.getChanges(); if (changes != null) { changes.setLogMessage(ModelUtil.clone(version.getLogMessage())); result.add(changes); } } // if source is after target in time if (!updateForward) { // reverse list and change packages final List<AbstractChangePackage> resultReverse = new ArrayList<AbstractChangePackage>(); for (final AbstractChangePackage changePackage : result) { final ChangePackage changePackageReverse = VersioningFactory.eINSTANCE.createChangePackage(); final ESCloseableIterable<AbstractOperation> reversedOperations = changePackage.reversedOperations(); final ArrayList<AbstractOperation> copiedReversedOperations = new ArrayList<AbstractOperation>(); try { for (final AbstractOperation op : reversedOperations.iterable()) { copiedReversedOperations.add(op.reverse()); } } finally { reversedOperations.close(); } for (final AbstractOperation reversedOperation : copiedReversedOperations) { changePackageReverse.add(reversedOperation); } // copy again log message // reverse() created a new change package without copying // existent attributes changePackageReverse.setLogMessage(ModelUtil.clone(changePackage.getLogMessage())); resultReverse.add(changePackageReverse); } Collections.reverse(resultReverse); result = resultReverse; } return result; } }
private PrimaryVersionSpec internalCreateVersion( ProjectId projectId, PrimaryVersionSpec baseVersionSpec, AbstractChangePackage changePackage, BranchVersionSpec targetBranch, PrimaryVersionSpec sourceVersion, LogMessage logMessage, final ACUser user) throws ESException { synchronized (getMonitor()) { final long currentTimeMillis = System.currentTimeMillis(); final ProjectHistory projectHistory = getSubInterface(ProjectSubInterfaceImpl.class).getProject(projectId); // Find branch final BranchInfo baseBranch = getBranchInfo(projectHistory, baseVersionSpec); final Version baseVersion = getVersion(projectHistory, baseVersionSpec); if (baseVersion == null || baseBranch == null) { throw new InvalidVersionSpecException( Messages.VersionSubInterfaceImpl_InvalidBranchOrVersion); } // defined here fore scoping reasons Version newVersion = null; BranchInfo newBranch = null; // copy project and apply changes final Project newProjectState = ((ProjectImpl) getSubInterface(ProjectSubInterfaceImpl.class).getProject(baseVersion)) .copy(); changePackage.apply(newProjectState); // regular commit if (isRegularCommit(targetBranch, baseVersion)) { newVersion = performRegularCommit( baseVersionSpec, logMessage, user, projectHistory, baseBranch, baseVersion, newProjectState); // case for new branch creation } else if (isNewBranchCommit(targetBranch, projectHistory)) { checkNewBranchCommitPreRequisites(targetBranch.getBranch()); // when branch does NOT exist, create new branch newVersion = createVersion(projectHistory, newProjectState, logMessage, user, baseVersion); newBranch = createNewBranch( projectHistory, baseVersion.getPrimarySpec(), newVersion.getPrimarySpec(), targetBranch); newVersion.setAncestorVersion(baseVersion); } else { // This point only can be reached with invalid input throw new IllegalStateException( Messages.VersionSubInterfaceImpl_TargetBranchCombination_Invalid); } if (sourceVersion != null) { newVersion.getMergedFromVersion().add(getVersion(projectHistory, sourceVersion)); } // try to save try { try { trySave(projectId, changePackage, projectHistory, newVersion, newProjectState); } catch (final FatalESException e) { // try to roll back. removing version is necessary in all cases rollback(projectHistory, baseBranch, baseVersion, newVersion, newBranch, e); } // if ancestor isn't null, a new branch was created. In this // case we want to keep the old base project // state if (newVersion.getAncestorVersion() == null && baseVersion.getProjectState() != null) { // delete projectstate from last revision depending on // persistence policy deleteOldProjectStateAccordingToOptions(projectId, baseVersion); } save(baseVersion); save(projectHistory); } catch (final FatalESException e) { // roll back failed EMFStoreController.getInstance().shutdown(e); throw new ESException(Messages.VersionSubInterfaceImpl_ShuttingServerDown); } ModelUtil.logInfo( Messages.VersionSubInterfaceImpl_TotalTimeForCommit + (System.currentTimeMillis() - currentTimeMillis)); return newVersion.getPrimarySpec(); } }