public void create(ISVNEditor commitEditor, final String path, final InputStream content)
throws SVNException, IOException {
final BufferedInputStream bis = new BufferedInputStream(content);
final String autoDetectedMimeType = detectMimeType(bis);
commitEditor.addFile(path, null, -1);
commitEditor.applyTextDelta(path, null);
SVNDeltaGenerator deltaGenerator = new SVNDeltaGenerator();
String checksum = deltaGenerator.sendDelta(path, bis, commitEditor, true);
final Map<String, String> autoprops = _autoPropertiesApplier.apply(path);
for (Map.Entry<String, String> entry : autoprops.entrySet()) {
commitEditor.changeFileProperty(
path, entry.getKey(), SVNPropertyValue.create(entry.getValue()));
}
if (!autoprops.containsKey(SVNProperty.MIME_TYPE) && autoDetectedMimeType != null) {
commitEditor.changeFileProperty(
path, SVNProperty.MIME_TYPE, SVNPropertyValue.create(autoDetectedMimeType));
}
commitEditor.closeFile(path, checksum);
}
protected void endElement(DAVElement parent, DAVElement element, StringBuffer cdata)
throws SVNException {
if (element == APPLY_TEXT_DELTA) {
setDeltaProcessing(false);
} else if (element == CHANGE_FILE_PROPERTY || element == CHANGE_DIR_PROPERTY) {
if (cdata != null && !"".equals(cdata.toString()) && myPropertyName == null) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_MALFORMED_DATA, "Got cdata content for a prop delete");
SVNErrorManager.error(err, SVNLogType.NETWORK);
}
if (myPropertyName != null) {
StringBuffer sb = SVNBase64.normalizeBase64(cdata);
byte[] buffer = allocateBuffer(sb.length());
int length = SVNBase64.base64ToByteArray(sb, buffer);
SVNPropertyValue property = SVNPropertyValue.create(myPropertyName, buffer, 0, length);
if (element == CHANGE_FILE_PROPERTY) {
myEditor.changeFileProperty(myPath, myPropertyName, property);
} else {
myEditor.changeDirProperty(myPropertyName, property);
}
}
}
}
private long commit() throws SVNException {
long oldRev = myFSFS.getYoungestRevision();
if (myTxn.getBaseRevision() != oldRev) {
SVNErrorMessage err =
SVNErrorMessage.create(SVNErrorCode.FS_TXN_OUT_OF_DATE, "Transaction out of date");
SVNErrorManager.error(err, SVNLogType.FSFS);
}
verifyLocks();
final String startNodeId;
final String startCopyId;
if (myFSFS.getDBFormat() < FSFS.MIN_NO_GLOBAL_IDS_FORMAT) {
String[] ids = myFSFS.getNextRevisionIDs();
startNodeId = ids[0];
startCopyId = ids[1];
} else {
startNodeId = null;
startCopyId = null;
}
final long newRevision = oldRev + 1;
final OutputStream protoFileOS = null;
final FSID newRootId = null;
final FSTransactionRoot txnRoot = getTxnRoot();
FSWriteLock txnWriteLock = FSWriteLock.getWriteLockForTxn(myTxn.getTxnId(), myFSFS);
synchronized (txnWriteLock) {
try {
// start transaction.
txnWriteLock.lock();
final File revisionPrototypeFile = txnRoot.getTransactionProtoRevFile();
final long offset = revisionPrototypeFile.length();
if (myFSFS.getRepositoryCacheManager() != null) {
myFSFS
.getRepositoryCacheManager()
.runWriteTransaction(
new IFSSqlJetTransaction() {
public void run() throws SVNException {
commit(
startNodeId,
startCopyId,
newRevision,
protoFileOS,
newRootId,
txnRoot,
revisionPrototypeFile,
offset);
}
});
} else {
commit(
startNodeId,
startCopyId,
newRevision,
protoFileOS,
newRootId,
txnRoot,
revisionPrototypeFile,
offset);
}
File dstRevFile = myFSFS.getNewRevisionFile(newRevision);
SVNFileUtil.rename(revisionPrototypeFile, dstRevFile);
} finally {
txnWriteLock.unlock();
FSWriteLock.release(txnWriteLock);
}
}
String commitTime = SVNDate.formatDate(new Date(System.currentTimeMillis()));
SVNProperties presetRevisionProperties = myFSFS.getTransactionProperties(myTxn.getTxnId());
if (presetRevisionProperties == null
|| !presetRevisionProperties.containsName(SVNRevisionProperty.DATE)) {
myFSFS.setTransactionProperty(
myTxn.getTxnId(), SVNRevisionProperty.DATE, SVNPropertyValue.create(commitTime));
}
File txnPropsFile = myFSFS.getTransactionPropertiesFile(myTxn.getTxnId());
if (myFSFS.getDBFormat() < FSFS.MIN_PACKED_REVPROP_FORMAT
|| newRevision >= myFSFS.getMinUnpackedRevProp()) {
File dstRevPropsFile = myFSFS.getNewRevisionPropertiesFile(newRevision);
SVNFileUtil.rename(txnPropsFile, dstRevPropsFile);
} else {
/* Read the revprops, and commit them to the permenant sqlite db. */
FSFile fsfProps = new FSFile(txnPropsFile);
try {
final SVNProperties revProperties = fsfProps.readProperties(false, true);
final SVNSqlJetStatement stmt =
myFSFS.getRevisionProperitesDb().getStatement(SVNWCDbStatements.FSFS_SET_REVPROP);
try {
stmt.insert(
new Object[] {newRevision, SVNSkel.createPropList(revProperties.asMap()).getData()});
} finally {
stmt.reset();
}
} finally {
fsfProps.close();
}
}
try {
txnRoot.writeFinalCurrentFile(newRevision, startNodeId, startCopyId);
} catch (IOException ioe) {
SVNErrorMessage err =
SVNErrorMessage.create(SVNErrorCode.IO_ERROR, ioe.getLocalizedMessage());
SVNErrorManager.error(err, ioe, SVNLogType.FSFS);
}
myFSFS.setYoungestRevisionCache(newRevision);
myFSFS.purgeTxn(myTxn.getTxnId());
return newRevision;
}
/**
* Pass the absolute path of the base directory where all example data will be created in arg[0].
* The sample will create:
*
* <p>- arg[0]/exampleRepository - repository with some test data - arg[0]/exampleWC - working
* copy checked out from exampleRepository
*/
public static void main(String[] args) {
// initialize SVNKit to work through file:/// protocol
SamplesUtility.initializeFSFSprotocol();
File baseDirectory = new File(args[0]);
File reposRoot = new File(baseDirectory, "exampleRepository");
File wcRoot = new File(baseDirectory, "exampleWC");
try {
// first create a repository and fill it with data
SamplesUtility.createRepository(reposRoot);
SVNCommitInfo info = SamplesUtility.createRepositoryTree(reposRoot);
// print out new revision info
System.out.println(info);
SVNClientManager clientManager = SVNClientManager.newInstance();
clientManager.setEventHandler(new EventHandler());
SVNURL reposURL = SVNURL.fromFile(reposRoot);
// copy A to A_copy in repository (url-to-url copy)
SVNCopyClient copyClient = clientManager.getCopyClient();
SVNURL A_URL = reposURL.appendPath("A", true);
SVNURL copyTargetURL = reposURL.appendPath("A_copy", true);
SVNCopySource copySource = new SVNCopySource(SVNRevision.UNDEFINED, SVNRevision.HEAD, A_URL);
info =
copyClient.doCopy(
new SVNCopySource[] {copySource},
copyTargetURL,
false,
false,
true,
"copy A to A_copy",
null);
// print out new revision info
System.out.println(info);
// checkout the entire repository tree
SamplesUtility.checkOutWorkingCopy(reposURL, wcRoot);
// now make some changes to the A tree
SamplesUtility.writeToFile(new File(wcRoot, "iota"), "New text appended to 'iota'", true);
SamplesUtility.writeToFile(new File(wcRoot, "A/mu"), "New text in 'mu'", false);
SVNWCClient wcClient = SVNClientManager.newInstance().getWCClient();
wcClient.doSetProperty(
new File(wcRoot, "A/B"),
"spam",
SVNPropertyValue.create("egg"),
false,
SVNDepth.EMPTY,
null,
null);
// commit local changes
SVNCommitClient commitClient = clientManager.getCommitClient();
commitClient.doCommit(
new File[] {wcRoot},
false,
"committing changes",
null,
null,
false,
false,
SVNDepth.INFINITY);
// now diff the base revision of the working copy against the repository
SVNDiffClient diffClient = clientManager.getDiffClient();
SVNRevisionRange rangeToMerge = new SVNRevisionRange(SVNRevision.create(1), SVNRevision.HEAD);
diffClient.doMerge(
A_URL,
SVNRevision.HEAD,
Collections.singleton(rangeToMerge),
new File(wcRoot, "A_copy"),
SVNDepth.UNKNOWN,
true,
false,
false,
false);
// now make some changes to the A tree again
// change file contents of iota and A/D/gamma
SamplesUtility.writeToFile(new File(wcRoot, "iota"), "New text2 appended to 'iota'", true);
SamplesUtility.writeToFile(new File(wcRoot, "A/D/gamma"), "New text in 'gamma'", false);
// remove A/C from version control
wcClient.doDelete(new File(wcRoot, "A/C"), false, true, false);
// commit local changes
commitClient.doCommit(
new File[] {wcRoot},
false,
"committing changes again",
null,
null,
false,
false,
SVNDepth.INFINITY);
/* do the same merge call, merge-tracking feature will merge only those revisions
* which were not still merged.
*/
diffClient.doMerge(
A_URL,
SVNRevision.HEAD,
Collections.singleton(rangeToMerge),
new File(wcRoot, "A_copy"),
SVNDepth.UNKNOWN,
true,
false,
false,
false);
} catch (SVNException svne) {
System.out.println(svne.getErrorMessage());
System.exit(1);
} catch (IOException ioe) {
ioe.printStackTrace();
System.exit(1);
}
}
