/** * @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 resolvePrimaryVersionSpec( ProjectHistory projectHistory, PrimaryVersionSpec versionSpec) throws InvalidVersionSpecException { final int index = versionSpec.getIdentifier(); final String branch = versionSpec.getBranch(); final int versions = projectHistory.getVersions().size(); if (0 > index || index >= versions || branch == null) { throw new InvalidVersionSpecException( MessageFormat.format(Messages.VersionSubInterfaceImpl_InvalidVersionRequested, index)); } if (branch.equals(VersionSpec.GLOBAL)) { return projectHistory.getVersions().get(index).getPrimarySpec(); } // Get biggest primary version of given branch which is equal or lower // to the given versionSpec for (int i = index; i >= 0; i--) { final Version version = projectHistory.getVersions().get(i); if (branch.equals(version.getPrimarySpec().getBranch())) { return version.getPrimarySpec(); } } throw new InvalidVersionSpecException(Messages.VersionSubInterfaceImpl_PrimaryVersionNotFound); }
private Version getVersion(ProjectHistory projectHistory, PrimaryVersionSpec baseVersionSpec) { if (0 > baseVersionSpec.getIdentifier() || baseVersionSpec.getIdentifier() > projectHistory.getVersions().size() - 1) { return null; } final Version version = projectHistory.getVersions().get(baseVersionSpec.getIdentifier()); if (version == null || !version.getPrimarySpec().equals(baseVersionSpec)) { return null; } return version; }
/** * Returns all branches for the project with the given ID. * * @param projectId the ID of a project * @return a list containing information about each branch * @throws ESException in case of failure */ @ESMethod(MethodId.GETBRANCHES) public List<BranchInfo> getBranches(ProjectId projectId) throws ESException { synchronized (getMonitor()) { final ProjectHistory projectHistory = getSubInterface(ProjectSubInterfaceImpl.class).getProject(projectId); final ArrayList<BranchInfo> result = new ArrayList<BranchInfo>(); for (final BranchInfo branch : projectHistory.getBranches()) { result.add(ModelUtil.clone(branch)); } return result; } }
private PrimaryVersionSpec resolveHeadVersionSpec( ProjectHistory projectHistory, HeadVersionSpec versionSpec) throws InvalidVersionSpecException { if (VersionSpec.GLOBAL.equals(versionSpec.getBranch())) { return projectHistory .getVersions() .get(projectHistory.getVersions().size() - 1) .getPrimarySpec(); } final BranchInfo info = getBranchInfo(projectHistory, versionSpec); if (info != null) { return info.getHead(); } throw new InvalidVersionSpecException(Messages.VersionSubInterfaceImpl_HeadVersionNotFound); }
private BranchInfo getBranchInfo(ProjectHistory projectHistory, VersionSpec versionSpec) { for (final BranchInfo branchInfo : projectHistory.getBranches()) { if (branchInfo.getName().equals(versionSpec.getBranch())) { return branchInfo; } } return null; }
private PrimaryVersionSpec resolveDateVersionSpec( ProjectHistory projectHistory, DateVersionSpec versionSpec) { for (final Version version : projectHistory.getVersions()) { final LogMessage logMessage = version.getLogMessage(); if (logMessage == null || logMessage.getDate() == null) { continue; } if (versionSpec.getDate().before(logMessage.getDate())) { final Version previousVersion = version.getPreviousVersion(); if (previousVersion == null) { return VersioningFactory.eINSTANCE.createPrimaryVersionSpec(); } return previousVersion.getPrimarySpec(); } } return projectHistory.getLastVersion().getPrimarySpec(); }
private Version createVersion( ProjectHistory projectHistory, Project projectState, LogMessage logMessage, ACUser user, Version previousVersion) throws ESException { final Version newVersion = VersioningFactory.eINSTANCE.createVersion(); long computedChecksum = ModelUtil.NO_CHECKSUM; try { if (ServerConfiguration.isComputeChecksumOnCommitActive()) { computedChecksum = ModelUtil.computeChecksum(projectState); } } catch (final SerializationException exception) { // TODO: clarify what to do in case checksum computation fails + provide ext. point throw new ESException( MessageFormat.format( Messages.VersionSubInterfaceImpl_ChecksumComputationFailed, projectHistory.getProjectName()), exception); } // newVersion.setChanges(changePackage); logMessage.setDate(new Date()); logMessage.setAuthor(user.getName()); newVersion.setLogMessage(logMessage); // latest version == getVersion.size() (version start with index 0 as // the list), branch from previous is used. newVersion.setPrimarySpec( Versions.createPRIMARY( previousVersion.getPrimarySpec(), projectHistory.getVersions().size())); newVersion.getPrimarySpec().setProjectStateChecksum(computedChecksum); newVersion.setNextVersion(null); projectHistory.getVersions().add(newVersion); return newVersion; }
private PrimaryVersionSpec resolveTagVersionSpec( ProjectHistory projectHistory, TagVersionSpec versionSpec) throws InvalidVersionSpecException { for (final Version version : projectHistory.getVersions()) { for (final TagVersionSpec tag : version.getTagSpecs()) { if (versionSpec.equals(tag)) { return ModelUtil.clone(version.getPrimarySpec()); } } } throw new InvalidVersionSpecException(Messages.VersionSubInterfaceImpl_TagVersionNotFound); }
private void rollback( final ProjectHistory projectHistory, final BranchInfo baseBranch, final Version baseVersion, Version newVersion, BranchInfo newBranch, final FatalESException e) throws StorageException { projectHistory.getVersions().remove(newVersion); if (newBranch == null) { // normal commit baseVersion.setNextVersion(null); baseBranch.setHead(ModelUtil.clone(baseVersion.getPrimarySpec())); } else { // branch commit baseVersion.getBranchedVersions().remove(newVersion); projectHistory.getBranches().remove(newBranch); } // TODO: delete obsolete project, change package and version files throw new StorageException(StorageException.NOSAVE, e); }
private BranchInfo createNewBranch( ProjectHistory projectHistory, PrimaryVersionSpec baseSpec, PrimaryVersionSpec primarySpec, BranchVersionSpec branch) { primarySpec.setBranch(branch.getBranch()); final BranchInfo branchInfo = VersioningFactory.eINSTANCE.createBranchInfo(); branchInfo.setName(branch.getBranch()); branchInfo.setSource(ModelUtil.clone(baseSpec)); branchInfo.setHead(ModelUtil.clone(primarySpec)); projectHistory.getBranches().add(branchInfo); return branchInfo; }
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; }