Refine search
private List<Version> getVersions(String nodePath, Session session) throws RepositoryException { List<Version> versions = new ArrayList<Version>(); for (VersionIterator iter = session.getWorkspace() .getVersionManager().getVersionHistory(nodePath) .getAllVersions(); iter.hasNext();) { Version v = iter.nextVersion(); versions.add(v); } return versions; }
public static Object getVersionSummary( final Session session, final PentahoJcrConstants pentahoJcrConstants, final Serializable fileId, final Serializable versionId ) throws RepositoryException { VersionManager vMgr = session.getWorkspace().getVersionManager(); Node fileNode = session.getNodeByIdentifier( fileId.toString() ); VersionHistory versionHistory = vMgr.getVersionHistory( fileNode.getPath() ); Version version = null; if ( versionId != null ) { version = versionHistory.getVersion( versionId.toString() ); } else { version = vMgr.getBaseVersion( fileNode.getPath() ); } return toVersionSummary( pentahoJcrConstants, versionHistory, version ); }
/** * Test that the initial base version after creation of a versionable node * points to the root version. * * @throws javax.jcr.RepositoryException */ public void testInitialBaseVersionPointsToRootVersionJcr2() throws RepositoryException { VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager(); String path = versionableNode.getPath(); Version rV = versionManager.getVersionHistory(path).getRootVersion(); Version bV = versionManager.getBaseVersion(path); assertTrue("After creation of a versionable node the node's baseVersion must point to the rootVersion in the version history.", rV.isSame(bV)); }
private Node getFrozenNode(Node node, String versionSpecifier) throws RepositoryException { final VersionManager versionManager = session.getWorkspace().getVersionManager(); final VersionHistory history = versionManager.getVersionHistory(node.getPath()); if (history.hasVersionLabel(versionSpecifier)) { return history.getVersionByLabel(versionSpecifier).getFrozenNode(); } else if (history.hasNode(versionSpecifier)) { return history.getVersion(versionSpecifier).getFrozenNode(); } else { return null; } }
private void restore(Node node, String versionSpecifier, boolean removeExisting) throws RepositoryException { final VersionManager vm = node.getSession().getWorkspace().getVersionManager(); final VersionHistory history = vm.getVersionHistory(node.getPath()); final Version version; if (history.hasVersionLabel(versionSpecifier)) { version = history.getVersionByLabel(versionSpecifier); } else if (history.hasNode(versionSpecifier)) { version = history.getVersion(versionSpecifier); } else { throw new IllegalArgumentException("Unable to process restore. Invalid version: " + versionSpecifier); } vm.restore(version, removeExisting); } }
/** * Test the removal of an version label that has successfully been added * before. * * @throws RepositoryException * @see VersionHistory#removeVersionLabel(String) */ public void testRemoveLabel() throws RepositoryException { vHistory.addVersionLabel(version.getName(), versionLabel, false); vHistory.removeVersionLabel(versionLabel); assertFalse("VersionHistory.removeLabel(String) must remove the version label if it exists (has successfully been added before).", vHistory.hasVersionLabel(versionLabel)); }
public void testVersionReferencesV0() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); String p = n.getPath(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); Version v0 = vMgr.getVersionHistory(p).getRootVersion(); // check if versionable node has references to root version assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString()); assertEquals("Root Version", v0.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString()); checkReferences("Root Version", v0.getReferences(), p + "/jcr:baseVersion", p + "/jcr:predecessors" ); }
/** * Test if the a label added with VersionHistory.addVersionLabel(String, * String, boolean) corresponds to adding a reference property to the * jcr:versionLabels node of this history node, with the label as name of * the property, and the reference targeting the version. * * @see VersionHistory#addVersionLabel(String, String, boolean) */ public void testAddVersionCheckVersionLabelsNodeJcr2() throws RepositoryException { vHistory.addVersionLabel(version.getName(), versionLabel, false); // get jcr:versionLabels node vHistory = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()); Node versionLabelNode = vHistory.getNode(jcrVersionLabels); assertTrue("The version label that has been successfully added must be present in the node '" + jcrVersionLabels + "'.", versionLabelNode.getProperty(versionLabel).getString().equals(version.getUUID())); }
/** * Test if after creation of a versionable node N the multi-value * REFERENCE property jcr:predecessors of N is initialized to contain a * single UUID, that of the root version (the same as jcr:baseVersion). * * @throws RepositoryException */ public void testInitialNodePredecessorsJcr2() throws RepositoryException { Property predecessors = versionableNode.getProperty(jcrPredecessors); Value[] values = predecessors.getValues(); Version rV = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion(); if (values.length != 1) { fail("The jcr:predecessors property of a versionable node must be initialized to contain a single value"); } Value initialVal = values[0]; assertTrue("The jcr:predecessors property of a versionable node is initialized to contain a single UUID, that of the root version", initialVal.equals(superuser.getValueFactory().createValue(rV))); }
public void testRemoveVersion() throws RepositoryException { Node n = testRootNode.addNode(nodeName1, testNodeType); n.addMixin(mixVersionable); superuser.save(); VersionManager vMgr = superuser.getWorkspace().getVersionManager(); vMgr.checkin(n.getPath()); Version v = vMgr.getBaseVersion(n.getPath()); try { v.getContainingHistory().removeVersion(v.getName()); fail("removeVersion() must fail with ReferentialIntegrityException"); } catch (ReferentialIntegrityException e) { // expected } vMgr.checkout(n.getPath()); v = vMgr.getBaseVersion(n.getPath()); try { v.getContainingHistory().removeVersion(v.getName()); fail("removeVersion() must fail with ReferentialIntegrityException"); } catch (ReferentialIntegrityException e) { // expected } }
public void testSuccessorsPredecessorsMergedOnRemove() throws Exception { Node node = testRootNode.addNode(nodeName1, ntUnstructured); node.addMixin(mixVersionable); superuser.save(); VersionManager vm = superuser.getWorkspace().getVersionManager(); VersionHistory history = vm.getVersionHistory(node.getPath()); vm.checkpoint(node.getPath()); // 1.0 Version v11 = vm.checkpoint(node.getPath()); vm.checkpoint(node.getPath()); // 1.2 vm.checkpoint(node.getPath()); // 1.3 vm.restore(v11, true); vm.checkpoint(node.getPath()); // 1.1 vm.checkpoint(node.getPath()); // 1.1.0 assertSuccessors(history, of("1.1.0", "1.2"), "1.1"); vm.checkpoint(node.getPath()); // 1.1.1 history.removeVersion("1.2"); assertSuccessors(history, of("1.1.0", "1.3"), "1.1"); }
@Test public void verifyNoVersionable() throws RepositoryException { Session session = createAdminSession(); VersionManager vMgr = session.getWorkspace().getVersionManager(); try { assertFalse(session.getNode("/versionable1").isNodeType(MIX_VERSIONABLE)); Node versionable2 = session.getNode("/versionable2"); assertTrue(versionable2.isNodeType(MIX_VERSIONABLE)); VersionHistory history = vMgr.getVersionHistory(versionable2.getPath()); VersionIterator versions = history.getAllVersions(); assertEquals("jcr:rootVersion", versions.nextVersion().getName()); assertFalse(versions.hasNext()); } finally { session.logout(); } } }
private InputStream readVersionFile(String path, String version) throws Exception{ path = processPath(path); Node rootNode=getRootNode(); if (!rootNode.hasNode(path)) { throw new RuleException("File [" + path + "] not exist."); } Node fileNode = rootNode.getNode(path); VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath()); Version v = versionHistory.getVersion(version); Node fnode = v.getFrozenNode(); Property property = fnode.getProperty(DATA); Binary fileBinary = property.getBinary(); return fileBinary.getStream(); }
/** * Tests if VersionHistory.getVersionableIdentifier() returns the ID of the * corresponding versionable node. * @since JCR 2.9 */ public void testGetVersionableIdentifier() throws RepositoryException { VersionManager vm = versionableNode.getSession().getWorkspace().getVersionManager(); vm.checkpoint(versionableNode.getPath()); assertEquals("Method getVersionableIdentifier() must return the identifier of the corresponding Node.", vm.getVersionHistory(versionableNode.getPath()).getVersionableIdentifier(), versionableNode.getIdentifier()); } }
/** * @since oak (DIFF: jr required jcr:versionManagement privilege on the version store) */ @Test public void testRemoveVersion() throws Exception { Node n = createVersionableNode(superuser.getNode(path)); Node trn = testSession.getNode(path); modify(trn.getPath(), Privilege.JCR_VERSION_MANAGEMENT, true); Node testNode = trn.getNode(n.getName()); Version v = testNode.checkin(); testNode.checkout(); testNode.checkin(); // removing a version must be allowed testNode.getVersionHistory().removeVersion(v.getName()); }
/** * Test if the iterator returned by {@link javax.jcr.version.VersionHistory#getAllLinearVersions()} * contains both the root and the base version upon creation of the version history. * @since JCR 2.0 */ public void testInitiallyGetAllLinearVersionsContainsTheRootAndTheBaseVersion() throws RepositoryException { VersionManager vm = versionableNode.getSession().getWorkspace().getVersionManager(); List<String> lvh = new ArrayList<String>(); for (VersionIterator it = vHistory.getAllLinearVersions(); it.hasNext(); ) { lvh.add(it.nextVersion().getName()); } String rootVersion = vm.getVersionHistory(versionableNode.getPath()).getRootVersion().getName(); String baseVersion = vm.getBaseVersion(versionableNode.getPath()).getName(); assertTrue("root version " + rootVersion + " must be part of the linear version history: " + lvh, lvh.contains(rootVersion)); assertTrue("base version " + baseVersion + " must be part of the linear version history: " + lvh, lvh.contains(baseVersion)); }
/** * Test if the root version does not have any predecessor versions. * * @throws RepositoryException */ public void testRootVersionHasNoPredecessorJcr2() throws RepositoryException { Version[] predec = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion().getPredecessors(); assertTrue("The root version may not have any predecessors.", predec.length == 0); }
/** * Test the restore of a versionable node using a label. * @throws RepositoryException */ public void testRestoreLabelJcr2() throws RepositoryException { // mark V1 with label test1 versionManager.getVersionHistory(versionableNode.getPath()).addVersionLabel(version.getName(), "test", true); // restore V1 via label. versionManager.restoreByLabel(versionableNode.getPath(), "test", true); String value = versionableNode.getProperty(propertyName1).getString(); assertEquals("Node.restore('test') not correctly restored", propertyValue1, value); }
private void populateEvolutions() { try { this.resolver = resource.getResourceResolver(); this.versionManager = resolver.adaptTo(Session.class).getWorkspace().getVersionManager(); this.history = versionManager.getVersionHistory(resource.getPath()); Iterator<Version> iter = history.getAllVersions(); while (iter.hasNext()) { Version next = iter.next(); String versionPath = next.getFrozenNode().getPath(); Resource versionResource = resolver.resolve(versionPath); versions.add(new EvolutionImpl(next, versionResource, config)); log.debug("Version={} added to EvolutionItem", next.getName()); } } catch (UnsupportedRepositoryOperationException e1) { log.warn("Could not find version for resource={}", resource.getPath()); } catch (Exception e) { log.error("Could not find versions", e); } }
@Test public void testFrozenNodeIsWrapped() throws Exception { // GIVEN Session session = MgnlContext.getJCRSession(RepositoryConstants.WEBSITE); VersionManager versionMan = Components.getComponent(VersionManager.class); Node node = session.getRootNode().addNode( "page", NodeTypes.Page.NAME); session.save(); Version createdVersion = versionMan.addVersion(node); VersionHistory versionHistory = versionMan.getVersionHistory(node); // WHEN Node frozenNode = versionHistory.getVersion(createdVersion.getName()).getFrozenNode(); // THEN assertTrue(frozenNode instanceof ContentDecoratorNodeWrapper); }