public void makeDir(String path) throws SVNException {
SVNPathUtil.checkPathIsValid(path);
FSTransactionRoot txnRoot = getTxnRoot();
String txnId = txnRoot.getTxnID();
FSParentPath parentPath = txnRoot.openPath(path, false, true);
if (parentPath.getRevNode() != null) {
SVNErrorManager.error(FSErrors.errorAlreadyExists(txnRoot, path, myFSFS), SVNLogType.FSFS);
}
if ((txnRoot.getTxnFlags() & FSTransactionRoot.SVN_FS_TXN_CHECK_LOCKS) != 0) {
FSCommitter.allowLockedOperation(myFSFS, path, myAuthor, myLockTokens, true, false);
}
makePathMutable(parentPath.getParent(), path);
FSRevisionNode subDirNode =
makeEntry(
parentPath.getParent().getRevNode(),
parentPath.getParent().getAbsPath(),
parentPath.getEntryName(),
true,
txnId);
txnRoot.putRevNodeToCache(parentPath.getAbsPath(), subDirNode);
addChange(
path,
subDirNode.getId(),
FSPathChangeKind.FS_PATH_CHANGE_ADD,
false,
false,
SVNRepository.INVALID_REVISION,
null,
SVNNodeKind.DIR);
}
public void makePathMutable(FSParentPath parentPath, String errorPath) throws SVNException {
FSTransactionRoot txnRoot = getTxnRoot();
String txnId = txnRoot.getTxnID();
if (parentPath.getRevNode().getId().isTxn()) {
return;
}
FSRevisionNode clone = null;
if (parentPath.getParent() != null) {
makePathMutable(parentPath.getParent(), errorPath);
FSID parentId = null;
String copyId = null;
switch (parentPath.getCopyStyle()) {
case FSCopyInheritance.COPY_ID_INHERIT_PARENT:
parentId = parentPath.getParent().getRevNode().getId();
copyId = parentId.getCopyID();
break;
case FSCopyInheritance.COPY_ID_INHERIT_NEW:
copyId = reserveCopyId(txnId);
break;
case FSCopyInheritance.COPY_ID_INHERIT_SELF:
copyId = null;
break;
case FSCopyInheritance.COPY_ID_INHERIT_UNKNOWN:
default:
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.UNKNOWN,
"FATAL error: can not make path ''{0}'' mutable",
errorPath);
SVNErrorManager.error(err, SVNLogType.FSFS);
}
String copyRootPath = parentPath.getRevNode().getCopyRootPath();
long copyRootRevision = parentPath.getRevNode().getCopyRootRevision();
FSRoot copyrootRoot = myFSFS.createRevisionRoot(copyRootRevision);
FSRevisionNode copyRootNode = copyrootRoot.getRevisionNode(copyRootPath);
FSID childId = parentPath.getRevNode().getId();
FSID copyRootId = copyRootNode.getId();
boolean isParentCopyRoot = false;
if (!childId.getNodeID().equals(copyRootId.getNodeID())) {
isParentCopyRoot = true;
}
String clonePath = parentPath.getParent().getAbsPath();
clone =
txnRoot.cloneChild(
parentPath.getParent().getRevNode(),
clonePath,
parentPath.getEntryName(),
copyId,
isParentCopyRoot);
txnRoot.putRevNodeToCache(parentPath.getAbsPath(), clone);
} else {
FSTransactionInfo txn = txnRoot.getTxn();
if (txn.getRootID().equals(txn.getBaseID())) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.UNKNOWN,
"FATAL error: txn ''{0}'' root id ''{1}'' matches base id ''{2}''",
new Object[] {txnId, txn.getRootID(), txn.getBaseID()});
SVNErrorManager.error(err, SVNLogType.FSFS);
}
clone = myFSFS.getRevisionNode(txn.getRootID());
}
parentPath.setRevNode(clone);
}
public void makeCopy(
FSRevisionRoot fromRoot, String fromPath, String toPath, boolean preserveHistory)
throws SVNException {
FSTransactionRoot txnRoot = getTxnRoot();
String txnId = txnRoot.getTxnID();
FSRevisionNode fromNode = fromRoot.getRevisionNode(fromPath);
FSParentPath toParentPath = txnRoot.openPath(toPath, false, true);
if ((txnRoot.getTxnFlags() & FSTransactionRoot.SVN_FS_TXN_CHECK_LOCKS) != 0) {
FSCommitter.allowLockedOperation(myFSFS, toPath, myAuthor, myLockTokens, true, false);
}
if (toParentPath.getRevNode() != null
&& toParentPath.getRevNode().getId().equals(fromNode.getId())) {
return;
}
FSPathChangeKind changeKind;
long mergeInfoStart = 0;
if (toParentPath.getRevNode() != null) {
changeKind = FSPathChangeKind.FS_PATH_CHANGE_REPLACE;
if (myFSFS.supportsMergeInfo()) {
mergeInfoStart = toParentPath.getRevNode().getMergeInfoCount();
}
} else {
changeKind = FSPathChangeKind.FS_PATH_CHANGE_ADD;
}
makePathMutable(toParentPath.getParent(), toPath);
String fromCanonPath = SVNPathUtil.canonicalizeAbsolutePath(fromPath);
copy(
toParentPath.getParent().getRevNode(),
toParentPath.getEntryName(),
fromNode,
preserveHistory,
fromRoot.getRevision(),
fromCanonPath,
txnId);
if (changeKind == FSPathChangeKind.FS_PATH_CHANGE_REPLACE) {
txnRoot.removeRevNodeFromCache(toParentPath.getAbsPath());
}
long mergeInfoEnd = 0;
if (myFSFS.supportsMergeInfo()) {
mergeInfoEnd = fromNode.getMergeInfoCount();
if (mergeInfoStart != mergeInfoEnd) {
incrementMergeInfoUpTree(toParentPath.getParent(), mergeInfoEnd - mergeInfoStart);
}
}
FSRevisionNode newNode = txnRoot.getRevisionNode(toPath);
addChange(
toPath,
newNode.getId(),
changeKind,
false,
false,
fromRoot.getRevision(),
fromCanonPath,
fromNode.getType());
}
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, SVNLogType.FSFS);
}
if (!revNode.getId().isTxn()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.FS_NOT_MUTABLE,
"Attempted to set textual contents of an immutable node");
SVNErrorManager.error(err, SVNLogType.FSFS);
}
OutputStream targetOS = null;
InputStream sourceStream = null;
long offset = -1;
long deltaStart = -1;
FSWriteLock txnLock = null;
try {
txnLock = FSWriteLock.getWriteLockForTxn(txnRoot.getTxnID(), txnRoot.getOwner());
txnLock.lock();
File targetFile = txnRoot.getTransactionProtoRevFile();
offset = targetFile.length();
targetOS = SVNFileUtil.openFileForWriting(targetFile, true);
CountingOutputStream revWriter = new CountingOutputStream(targetOS, offset);
FSRepresentation baseRep = revNode.chooseDeltaBase(txnRoot.getOwner());
sourceStream =
FSInputStream.createDeltaStream(new SVNDeltaCombiner(), baseRep, txnRoot.getOwner());
String header;
if (baseRep != null) {
header =
FSRepresentation.REP_DELTA
+ " "
+ baseRep.getRevision()
+ " "
+ baseRep.getOffset()
+ " "
+ baseRep.getSize()
+ "\n";
} else {
header = FSRepresentation.REP_DELTA + "\n";
}
revWriter.write(header.getBytes("UTF-8"));
deltaStart = revWriter.getPosition();
if (dstStream instanceof FSOutputStream) {
FSOutputStream fsOS = (FSOutputStream) dstStream;
fsOS.reset(
revNode, revWriter, targetFile, sourceStream, deltaStart, 0, offset, txnRoot, txnLock);
return dstStream;
}
return new FSOutputStream(
revNode,
revWriter,
targetFile,
sourceStream,
deltaStart,
0,
offset,
txnRoot,
compress,
txnLock);
} catch (IOException ioe) {
SVNFileUtil.closeFile(targetOS);
SVNFileUtil.closeFile(sourceStream);
txnLock.unlock();
FSWriteLock.release(txnLock);
SVNErrorMessage err =
SVNErrorMessage.create(SVNErrorCode.IO_ERROR, ioe.getLocalizedMessage());
SVNErrorManager.error(err, ioe, SVNLogType.FSFS);
} catch (SVNException svne) {
if (txnLock != null) {
txnLock.unlock();
FSWriteLock.release(txnLock);
}
SVNFileUtil.closeFile(targetOS);
SVNFileUtil.closeFile(sourceStream);
throw svne;
}
return null;
}