hg4j: src/org/tmatesoft/hg/core/HgCloneCommand.java comparison

comparison src/org/tmatesoft/hg/core/HgCloneCommand.java @ 532:688c1ab113bb

Introduce explicit reference to base patch in bundle's group element, use it when cloning to fix defect when few revisions list null,null parents

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Wed, 23 Jan 2013 19:14:15 +0100
parents	95c2f43008bd
children	243202f1bda5

comparison

equal deleted inserted replaced

-:95c2f43008bd
+:688c1ab113bb
 		private final TreeMap<Nodeid, Integer> changelogIndexes = new TreeMap<Nodeid, Integer>();
 		private boolean collectChangelogIndexes = false;
 		private DataAccess prevRevContent;
 		private final DigestHelper dh = new DigestHelper();
-		private final ArrayList<Nodeid> revisionSequence = new ArrayList<Nodeid>(); // last visited nodes first
+		// recently processed nodes last, so that index in the array may be used as a linkRevision or baseRevision
+		private final ArrayList<Nodeid> revisionSequence = new ArrayList<Nodeid>();
 		private final LinkedList<String> fncacheFiles = new LinkedList<String>();
 		private RepoInitializer repoInit;
 		private Lifecycle.Callback lifecycleCallback;
 		private CancelledException cancelException;
 				revlogHeader.offset(0).baseRevision(-1);
 				revisionSequence.clear();
 				indexFile = new FileOutputStream(new File(hgDir, filename = "store/00changelog.i"));
 				collectChangelogIndexes = true;
 			} catch (IOException ex) {
-				throw new HgInvalidControlFileException("Failed to write changelog", ex, new File(filename));
+				throw new HgInvalidControlFileException("Failed to write changelog", ex, new File(hgDir, filename));
 			}
 			stopIfCancelled();
 		}
 		public void changelogEnd() {
 			try {
-				if (prevRevContent != null) {
+				clearPreviousContent();
-					prevRevContent.done();
-					prevRevContent = null;
-				}
 				collectChangelogIndexes = false;
-				indexFile.close();
+				closeIndexFile();
-				indexFile = null;
+			} catch (IOException ex) {
-				filename = null;
+				throw new HgInvalidControlFileException("Failed to write changelog", ex, new File(hgDir, filename));
-			} catch (IOException ex) {
-				throw new HgInvalidControlFileException("Failed to write changelog", ex, new File(filename));
 			}
 			progressSupport.worked(1);
 			stopIfCancelled();
 		}
 			try {
 				revlogHeader.offset(0).baseRevision(-1);
 				revisionSequence.clear();
 				indexFile = new FileOutputStream(new File(hgDir, filename = "store/00manifest.i"));
 			} catch (IOException ex) {
-				throw new HgInvalidControlFileException("Failed to write manifest", ex, new File(filename));
+				throw new HgInvalidControlFileException("Failed to write manifest", ex, new File(hgDir, filename));
 			}
 			stopIfCancelled();
 		}
 		public void manifestEnd() {
 			try {
-				if (prevRevContent != null) {
+				clearPreviousContent();
-					prevRevContent.done();
+				closeIndexFile();
-					prevRevContent = null;
+			} catch (IOException ex) {
-				}
+				throw new HgInvalidControlFileException("Failed to write manifest", ex, new File(hgDir, filename));
-				indexFile.close();
-				indexFile = null;
-				filename = null;
-			} catch (IOException ex) {
-				throw new HgInvalidControlFileException("Failed to write changelog", ex, new File(filename));
 			}
 			progressSupport.worked(1);
 			stopIfCancelled();
 		}
 			stopIfCancelled();
 		}
 		public void fileEnd(String name) {
 			try {
-				if (prevRevContent != null) {
+				clearPreviousContent();
-					prevRevContent.done();
+				closeIndexFile();
-					prevRevContent = null;
-				}
-				indexFile.close();
-				indexFile = null;
-				filename = null;
 			} catch (IOException ex) {
 				String m = String.format("Failed to write file %s", filename);
 				throw new HgInvalidControlFileException(m, ex, new File(filename));
 			}
 			progressSupport.worked(1);
 			stopIfCancelled();
+		}
+		private void clearPreviousContent() {
+			if (prevRevContent != null) {
+				prevRevContent.done();
+				prevRevContent = null;
+			}
+		}
+		private void closeIndexFile() throws IOException {
+			indexFile.close();
+			indexFile = null;
+			filename = null;
 		}
 		private int knownRevision(Nodeid p) {
 			if (p.isNull()) {
 				return -1;
 						return i;
 					}
 				}
 			}
 			String m = String.format("Can't find index of %s for file %s", p.shortNotation(), filename);
-			throw new HgInvalidControlFileException(m, null, null).setRevision(p);
+			throw new HgInvalidControlFileException(m, null, new File(hgDir, filename)).setRevision(p);
 		}
 		private RevlogStreamWriter.HeaderWriter revlogHeader = new RevlogStreamWriter.HeaderWriter(true);
 		private RevlogCompressor revlogDataZip = new RevlogCompressor();
 		public boolean element(GroupElement ge) {
 			try {
 				assert indexFile != null;
 				boolean writeComplete = false;
+				Nodeid deltaBase = ge.patchBase();
+				if (deltaBase.isNull()) {
+					// NOTE, can't use both parents isNull == true to empty prevRevContent
+					// see build.gradle sample below why.
+					prevRevContent = new DataAccess(); // empty data
+					writeComplete = true;
+					// if (writeComplete) would set baseRevision correctly,
+				} else {
+					Nodeid prevRevision = revisionSequence.size() > 0 ? revisionSequence.get(revisionSequence.size()-1) : Nodeid.NULL;
+					if (!prevRevision.equals(deltaBase)) {
+						// presently, bundle group elements always patch previous, see
+						// (a) changegroup.py#builddeltaheader(): # do nothing with basenode, it is implicitly the previous one in HG10
+						// (b) revlog.py#group(): prev, curr = revs[r], revs[r + 1]
+						//               for c in bundler.revchunk(self, curr, prev):
+						// so there's no reason to have code here to extract contents of deltaBase revision
+						String m = String.format("Revision %s import failed: delta base %s is not the last node we've handled (and know content for) %s", ge.node(), deltaBase, prevRevision);
+						throw new HgInvalidStateException(m);
+					}
+				}
+				//
+				byte[] content = ge.apply(prevRevContent.byteArray());
 				Nodeid p1 = ge.firstParent();
 				Nodeid p2 = ge.secondParent();
-				if (p1.isNull() && p2.isNull() /* or forced flag, does REVIDX_PUNCHED_FLAG indicate that? */) {
-					// FIXME NOTE, both parents isNull == true doesn't necessarily mean
-					// empty prevContent, see build.gradle sample below
-					prevRevContent = new ByteArrayDataAccess(new byte[0]);
-					writeComplete = true;
-				}
-				byte[] content = ge.apply(prevRevContent.byteArray());
 				byte[] calculated = dh.sha1(p1, p2, content).asBinary();
 				final Nodeid node = ge.node();
 				if (!node.equalsTo(calculated)) {
 					String m = String.format("Checksum failed: expected %s, calculated %s. File %s", node, calculated, filename);
 					throw new HgRevisionIntegrityException(m, null, new File(hgDir, filename));
 				}
 				revlogHeader.nodeid(node);
+				//
 				if (collectChangelogIndexes) {
 					changelogIndexes.put(node, revisionSequence.size());
 					revlogHeader.linkRevision(revisionSequence.size());
 				} else {
 					Integer csRev = changelogIndexes.get(ge.cset());
 					if (csRev == null) {
 						throw new HgInvalidStateException(String.format("Changelog doesn't contain revision %s of %s", ge.cset().shortNotation(), filename));
 					}
 					revlogHeader.linkRevision(csRev.intValue());
 				}
+				//
 				revlogHeader.parents(knownRevision(p1), knownRevision(p2));
+				//
 				byte[] patchContent = ge.rawDataByteArray();
+				// no reason to keep patch if it's close (here, >75%) in size to the complete contents,
+				// save patching effort in this case
 				writeComplete = writeComplete || patchContent.length >= (/* 3/4 of actual */content.length - (content.length >>> 2));
 				if (writeComplete) {
 					revlogHeader.baseRevision(revisionSequence.size());
 				}
+				assert revlogHeader.baseRevision() >= 0;
 				final byte[] sourceData = writeComplete ? content : patchContent;
 				revlogDataZip.reset(sourceData);
 				final int compressedLen;
 				final boolean useUncompressedData = revlogDataZip.getCompressedLengthEstimate() >= (sourceData.length - (sourceData.length >>> 2));
 				if (useUncompressedData) {
 d0be588453068787dcb3ee05f8edfe47fdd5ae78 4011d52141cd717c92cbf350a93522d2f3ee415e 0000000000000000000000000000000000000000 ad0322a4af204547c400e1846b2b83d446ab8da5 4011d52141cd717c92cbf350a93522d2f3ee415e 85
 3ddd456244a08f81779163d9faf922a6dcd9e53e d0be588453068787dcb3ee05f8edfe47fdd5ae78 0000000000000000000000000000000000000000 3ace1fc95d0a1a941b6427c60b6e624f96dd71ad d0be588453068787dcb3ee05f8edfe47fdd5ae78 151
 a3f374fbf33aba1cc3b4f472db022b5185880f5d 3ddd456244a08f81779163d9faf922a6dcd9e53e 0000000000000000000000000000000000000000 3ca4ae7bdd3890b8ed89bfea1b42af593e04b373 3ddd456244a08f81779163d9faf922a6dcd9e53e 195
 0227d28e0db69afebee34cd5a4151889fb6271da a3f374fbf33aba1cc3b4f472db022b5185880f5d 0000000000000000000000000000000000000000 31bd09da0dcfe48e1fc662143f91ff402238aa84 a3f374fbf33aba1cc3b4f472db022b5185880f5d 145
-but there's no delta base information in the bundle file, it's merely a hard-coded convention (always patches previous version, see
+but there's no delta base information in the bundle file, it's merely a hard-coded convention
-(a) changegroup.py#builddeltaheader(): # do nothing with basenode, it is implicitly the previous one in HG10
-(b) revlog.py#group(): prev, curr = revs[r], revs[r + 1]
-for c in bundler.revchunk(self, curr, prev):
-)
 It's unclear where the first chunk (identified 62a101b7...) comes from (by the way, there's no such changeset as 6ec4af... as specified in the chunk, while 7dcc920e.. IS changeset 454)
 EXPLANATION:
 if cloned repository comes from svnkit repo (where's the gradle branch):

Mercurial > hg4j

comparison src/org/tmatesoft/hg/core/HgCloneCommand.java @ 532:688c1ab113bb