private void deleteEntryIfMutable(FSID id) throws SVNException { FSRevisionNode node = getOwner().getRevisionNode(id); if (!node.getId().isTxn()) { return; } if (node.getType() == SVNNodeKind.DIR) { Map entries = node.getDirEntries(getOwner()); for (Iterator names = entries.keySet().iterator(); names.hasNext();) { String name = (String) names.next(); FSEntry entry = (FSEntry) entries.get(name); deleteEntryIfMutable(entry.getId()); } } removeRevisionNode(id); }
public long getFileSize(String path) throws SVNException { FSRevisionNode fileNode = getRevisionNode(path); return fileNode.getFileLength(); }
private Map collectProperties(FSRevisionNode revNode) throws SVNException { Map properties = new HashMap(); Map versionedProps = revNode.getProperties(myFSFS); if (versionedProps != null && versionedProps.size() > 0) { properties.putAll(versionedProps); } Map metaprops = null; try { metaprops = myFSFS.compoundMetaProperties(revNode.getId().getRevision()); } catch (SVNException svne) { // } if (metaprops != null && metaprops.size() > 0) { properties.putAll(metaprops); } return properties; }
public static FSRevisionNode dumpRevisionNode(FSRevisionNode revNode) { FSRevisionNode clone = new FSRevisionNode(); clone.setId(revNode.getId()); if (revNode.getPredecessorId() != null) { clone.setPredecessorId(revNode.getPredecessorId()); } clone.setType(revNode.getType()); clone.setCopyFromPath(revNode.getCopyFromPath()); clone.setCopyFromRevision(revNode.getCopyFromRevision()); clone.setCopyRootPath(revNode.getCopyRootPath()); clone.setCopyRootRevision(revNode.getCopyRootRevision()); clone.setCount(revNode.getCount()); clone.setCreatedPath(revNode.getCreatedPath()); if (revNode.getPropsRepresentation() != null) { clone.setPropsRepresentation(new FSRepresentation(revNode.getPropsRepresentation())); } if (revNode.getTextRepresentation() != null) { clone.setTextRepresentation(new FSRepresentation(revNode.getTextRepresentation())); } return clone; }
public void createNewTxnNodeRevisionFromRevision(String txnID, FSRevisionNode sourceNode) throws SVNException { if (sourceNode.getId().isTxn()) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_CORRUPT, "Copying from transactions not allowed"); SVNErrorManager.error(err); } FSRevisionNode revNode = FSRevisionNode.dumpRevisionNode(sourceNode); revNode.setPredecessorId(sourceNode.getId()); revNode.setCount(revNode.getCount() + 1); revNode.setCopyFromPath(null); revNode.setCopyFromRevision(FSRepository.SVN_INVALID_REVNUM); revNode.setId(FSID.createTxnId(sourceNode.getId().getNodeID(), sourceNode.getId().getCopyID(), txnID)); putTxnRevisionNode(revNode.getId(), revNode); }
private void copy(FSRevisionNode toNode, String entryName, FSRevisionNode fromNode, boolean preserveHistory, long fromRevision, String fromPath, String txnId) throws SVNException { FSID id = null; if (preserveHistory) { FSID srcId = fromNode.getId(); FSRevisionNode toRevNode = FSRevisionNode.dumpRevisionNode(fromNode); String copyId = reserveCopyId(txnId); toRevNode.setPredecessorId(srcId); if (toRevNode.getCount() != -1) { toRevNode.setCount(toRevNode.getCount() + 1); } toRevNode.setCreatedPath(SVNPathUtil.concatToAbs(toNode.getCreatedPath(), entryName)); toRevNode.setCopyFromPath(fromPath); toRevNode.setCopyFromRevision(fromRevision); toRevNode.setCopyRootPath(null); id = myTxnRoot.createSuccessor(srcId, toRevNode, copyId); } else { id = fromNode.getId(); } myTxnRoot.setEntry(toNode, entryName, id, fromNode.getType()); }
public FSRevisionNode cloneChild(FSRevisionNode parent, String parentPath, String childName, String copyId, boolean isParentCopyRoot) throws SVNException { if (!parent.getId().isTxn()) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_MUTABLE, "Attempted to clone child of non-mutable node"); SVNErrorManager.error(err); } if (!SVNPathUtil.isSinglePathComponent(childName)) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_SINGLE_PATH_COMPONENT, "Attempted to make a child clone with an illegal name ''{0}''", childName); SVNErrorManager.error(err); } FSRevisionNode childNode = parent.getChildDirNode(childName, getOwner()); FSID newNodeId = null; if (childNode.getId().isTxn()) { newNodeId = childNode.getId(); } else { if (isParentCopyRoot) { childNode.setCopyRootPath(parent.getCopyRootPath()); childNode.setCopyRootRevision(parent.getCopyRootRevision()); } childNode.setCopyFromPath(null); childNode.setCopyFromRevision(FSRepository.SVN_INVALID_REVNUM); childNode.setPredecessorId(childNode.getId()); if (childNode.getCount() != -1) { childNode.setCount(childNode.getCount() + 1); } childNode.setCreatedPath(SVNPathUtil.concatToAbs(parentPath, childName)); newNodeId = createSuccessor(childNode.getId(), childNode, copyId); setEntry(parent, childName, newNodeId, childNode.getType()); } return getOwner().getRevisionNode(newNodeId); }
public FSRevisionNode makeEntry(FSRevisionNode parent, String parentPath, String entryName, boolean isDir, String txnId) throws SVNException { if (!SVNPathUtil.isSinglePathComponent(entryName)) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_SINGLE_PATH_COMPONENT, "Attempted to create a node with an illegal name ''{0}''", entryName); SVNErrorManager.error(err); } if (parent.getType() != SVNNodeKind.DIR) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_DIRECTORY, "Attempted to create entry in non-directory parent"); SVNErrorManager.error(err); } if (!parent.getId().isTxn()) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_MUTABLE, "Attempted to clone child of non-mutable node"); SVNErrorManager.error(err); } FSRevisionNode newRevNode = new FSRevisionNode(); newRevNode.setType(isDir ? SVNNodeKind.DIR : SVNNodeKind.FILE); newRevNode.setCreatedPath(SVNPathUtil.concatToAbs(parentPath, entryName)); newRevNode.setCopyRootPath(parent.getCopyRootPath()); newRevNode.setCopyRootRevision(parent.getCopyRootRevision()); newRevNode.setCopyFromRevision(FSRepository.SVN_INVALID_REVNUM); newRevNode.setCopyFromPath(null); FSID newNodeId = createNode(newRevNode, parent.getId().getCopyID(), txnId); FSRevisionNode childNode = myFSFS.getRevisionNode(newNodeId); myTxnRoot.setEntry(parent, entryName, childNode.getId(), newRevNode.getType()); return childNode; }
public static FSRevisionNode fromMap(Map headers) throws SVNException { FSRevisionNode revNode = new FSRevisionNode(); revNode.setId(revnodeID); revNode.setType(nodeKind); revNode.setCount(0); } else { long cnt = -1; revNode.setCount(cnt); parseRepresentationHeader(propsRepr, revNode, revnodeID.getTxnID(), false); parseRepresentationHeader(textRepr, revNode, revnodeID.getTxnID(), true); revNode.setCreatedPath(cpath); revNode.setPredecessorId(predRevNodeId); revNode.setCopyRootPath(revNode.getCreatedPath()); revNode.setCopyRootRevision(revNode.getId().getRevision()); } else { parseCopyRoot(copyroot, revNode); revNode.setCopyFromPath(null); revNode.setCopyFromRevision(FSRepository.SVN_INVALID_REVNUM); } else { parseCopyFrom(copyfrom, revNode);
FSRevisionNode revNode = new FSRevisionNode(); revNode.setId(revNodeID); revNode.setType(nodeKind); FSRevisionNode.parseRepresentationHeader(textRep, revNode, null, true, false); if (revNode.getTextRepresentation().getRevision() != rev) { return; revFile.seek(revNode.getTextRepresentation().getOffset()); FSInputStream.FSRepresentationState repState = FSInputStream.readRepresentationLine(revFile); if (repState.myIsDelta) {
private SVNDirEntry buildDirEntry(FSEntry repEntry, SVNURL parentURL, FSRevisionNode entryNode, boolean includeLogs) throws SVNException { entryNode = entryNode == null ? myFSFS.getRevisionNode(repEntry.getId()) : entryNode; long size = 0; if (entryNode.getType() == SVNNodeKind.FILE) { size = entryNode.getFileLength(); } Map props = null; props = entryNode.getProperties(myFSFS); boolean hasProps = (props == null || props.size() == 0) ? false : true; Map revProps = null; revProps = myFSFS.getRevisionProperties(repEntry.getId().getRevision()); String lastAuthor = null; String log = null; Date lastCommitDate = null; if (revProps != null && revProps.size() > 0) { lastAuthor = (String) revProps.get(SVNRevisionProperty.AUTHOR); log = (String) revProps.get(SVNRevisionProperty.LOG); String timeString = (String) revProps.get(SVNRevisionProperty.DATE); lastCommitDate = timeString != null ? SVNTimeUtil.parseDateString(timeString) : null; } SVNURL entryURL = parentURL.appendPath(repEntry.getName(), false); SVNDirEntry dirEntry = new SVNDirEntry(entryURL, repEntry.getName(), repEntry.getType(), size, hasProps, repEntry.getId().getRevision(), lastCommitDate, lastAuthor, includeLogs ? log : null); dirEntry.setRelativePath(repEntry.getName()); return dirEntry; }
private Map crawlDirectoryForMergeInfo(FSRevisionRoot root, String path, FSRevisionNode node, Map result) throws SVNException { FSFS fsfs = root.getOwner(); Map entries = node.getDirEntries(fsfs); for (Iterator entriesIter = entries.values().iterator(); entriesIter.hasNext();) { FSEntry entry = (FSEntry) entriesIter.next(); String kidPath = SVNPathUtil.getAbsolutePath(SVNPathUtil.append(path, entry.getName())); FSRevisionNode kidNode = root.getRevisionNode(kidPath); if (kidNode.hasMergeInfo()) { SVNProperties propList = kidNode.getProperties(fsfs); String mergeInfoString = propList.getStringValue(SVNProperty.MERGE_INFO); if (mergeInfoString == null) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_CORRUPT, "Node-revision #''{0}'' claims to have mergeinfo but doesn''t", entry.getId()); SVNErrorManager.error(err, SVNLogType.FSFS); } Map kidMergeInfo = SVNMergeInfoUtil.parseMergeInfo(new StringBuffer(mergeInfoString), null); result.put(kidPath, kidMergeInfo); } if (kidNode.hasDescendantsWithMergeInfo()) { crawlDirectoryForMergeInfo(root, kidPath, kidNode, result); } } return result; }
private FSEntry fakeDirEntry(String reposPath, FSRoot root) throws SVNException { if (root.checkNodeKind(reposPath) == SVNNodeKind.NONE) { return null; } FSRevisionNode node = root.getRevisionNode(reposPath); FSEntry dirEntry = new FSEntry(node.getId(), node.getType(), SVNPathUtil.tail(node.getCreatedPath())); return dirEntry; }
public static OutputStream createStream(FSRevisionNode revNode, FSTransactionRoot txnRoot, OutputStream dstStream, boolean compress) throws SVNException { if (revNode.getType() != SVNNodeKind.FILE) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_FILE, "Attempted to set textual contents of a *non*-file node"); SVNErrorManager.error(err); if (!revNode.getId().isTxn()) { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.FS_NOT_MUTABLE, "Attempted to set textual contents of an immutable node"); SVNErrorManager.error(err); CountingStream revWriter = new CountingStream(targetOS, offset); FSRepresentation baseRep = revNode.chooseDeltaBase(txnRoot.getOwner()); sourceStream = FSInputStream.createDeltaStream(new SVNDeltaCombiner(), baseRep, txnRoot.getOwner()); String header;
public FSRevisionNode getRevisionNode(FSID id) throws SVNException { FSFile revisionFile = null; if (id.isTxn()) { File file = new File(getTransactionDir(id.getTxnID()), PATH_PREFIX_NODE + id.getNodeID() + "." + id.getCopyID()); revisionFile = new FSFile(file); } else { revisionFile = openAndSeekRevision(id.getRevision(), id.getOffset()); } Map headers = null; try { headers = revisionFile.readHeader(); } finally{ revisionFile.close(); } FSRevisionNode node = FSRevisionNode.fromMap(headers); if (node.isFreshTxnRoot()) { node.setFreshRootPredecessorId(node.getPredecessorId()); } return node; }
public FSTransactionInfo getTxn() throws SVNException { FSID rootID = FSID.createTxnId("0", "0", myTxnID); FSRevisionNode revNode = getOwner().getRevisionNode(rootID); FSTransactionInfo txn = new FSTransactionInfo(revNode.getId(), revNode.getPredecessorId()); return txn; }
public SVNLocationEntry getPreviousLocation(String path, long[] appearedRevision) throws SVNException { if (appearedRevision != null && appearedRevision.length > 0) { appearedRevision[0] = SVNRepository.INVALID_REVISION; } FSClosestCopy closestCopy = getClosestCopy(path); if (closestCopy == null) { return null; } FSRevisionRoot copyTargetRoot = closestCopy.getRevisionRoot(); String copyTargetPath = closestCopy.getPath(); FSRevisionNode copyFromNode = copyTargetRoot.getRevisionNode(copyTargetPath); String copyFromPath = copyFromNode.getCopyFromPath(); long copyFromRevision = copyFromNode.getCopyFromRevision(); String remainder = ""; if (!path.equals(copyTargetPath)) { remainder = path.substring(copyTargetPath.length()); if (remainder.startsWith("/")) { remainder = remainder.substring(1); } } String previousPath = SVNPathUtil.getAbsolutePath(SVNPathUtil.append(copyFromPath, remainder)); if (appearedRevision != null && appearedRevision.length > 0) { appearedRevision[0] = copyTargetRoot.getRevision(); } return new SVNLocationEntry(copyFromRevision, previousPath); }
public void closeDir() throws SVNException { if (myIsVerify) { FSRevisionNode node = myRoot.getRevisionNode(myCurrentDirInfo.myFullPath); Map entries = node.getDirEntries(myFSFS); for (Iterator entriesIter = entries.keySet().iterator(); entriesIter.hasNext();) { String entryName = (String) entriesIter.next(); String entryPath = SVNPathUtil.append(myCurrentDirInfo.myFullPath, entryName); SVNNodeKind kind = myRoot.checkNodeKind(entryPath); FSRevisionNode entryNode = myRoot.getRevisionNode(entryPath); if (kind == SVNNodeKind.DIR) { entryNode.getDirEntries(myFSFS); } else if (kind == SVNNodeKind.FILE) { entryNode.getFileLength(); } else { SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.NODE_UNEXPECTED_KIND, "Unexpected node kind {0} for ''{1}''", new Object[] { kind, entryPath }); SVNErrorManager.error(err, SVNLogType.FSFS); } } } for (Iterator entries = myCurrentDirInfo.myDeletedEntries.keySet().iterator(); entries.hasNext();) { String path = (String) entries.next(); dumpNode(path, SVNNodeKind.UNKNOWN, SVNAdminHelper.NODE_ACTION_DELETE, false, null, -1); } myCurrentDirInfo = myCurrentDirInfo.myParentInfo; }
} else { try { child = here.getChildDirNode(entry, getOwner()); } catch (SVNException svne) { if (svne.getErrorMessage().getErrorCode() == SVNErrorCode.FS_NOT_FOUND) { if (child.getType() != SVNNodeKind.DIR) { SVNErrorMessage err = FSErrors.errorNotDirectory(pathSoFar, getOwner()); SVNErrorManager.error(err.wrap("Failure opening ''{0}''", path));
private SVNProperties collectProperties(FSRevisionNode revNode) throws SVNException { SVNProperties properties = new SVNProperties(); SVNProperties versionedProps = revNode.getProperties(myFSFS); if (versionedProps != null && versionedProps.size() > 0) { properties.putAll(versionedProps); } SVNProperties metaprops = null; try { metaprops = myFSFS.compoundMetaProperties(revNode.getCreatedRevision()); } catch (SVNException svne) { // } if (metaprops != null && metaprops.size() > 0) { properties.putAll(metaprops); } return properties; }