hg4j: src/org/tmatesoft/hg/repo/HgBundle.java comparison

comparison src/org/tmatesoft/hg/repo/HgBundle.java @ 673:545b1d4cc11d

Refactor HgBundle.GroupElement (clear experimental mark), resolve few technical debt issues

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Fri, 12 Jul 2013 20:14:24 +0200
parents	fba85bc1dfb8
children

comparison

equal deleted inserted replaced

-:d2552e6a5af6
+:545b1d4cc11d
 * contact TMate Software at support@hg4j.com
 */
 package org.tmatesoft.hg.repo;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.ConcurrentModificationException;
 import org.tmatesoft.hg.core.HgIOException;
 import org.tmatesoft.hg.core.Nodeid;
 import org.tmatesoft.hg.core.SessionContext;
 import org.tmatesoft.hg.internal.ByteArrayChannel;
 import org.tmatesoft.hg.internal.ByteArrayDataAccess;
 import org.tmatesoft.hg.internal.Callback;
+import org.tmatesoft.hg.internal.ChangesetParser;
 import org.tmatesoft.hg.internal.DataAccess;
+import org.tmatesoft.hg.internal.DataAccessInputStream;
 import org.tmatesoft.hg.internal.DataAccessProvider;
-import org.tmatesoft.hg.internal.DataSerializer;
 import org.tmatesoft.hg.internal.DigestHelper;
 import org.tmatesoft.hg.internal.EncodingHelper;
 import org.tmatesoft.hg.internal.Experimental;
-import org.tmatesoft.hg.internal.FileUtils;
 import org.tmatesoft.hg.internal.InflaterDataAccess;
 import org.tmatesoft.hg.internal.Internals;
 import org.tmatesoft.hg.internal.Lifecycle;
 import org.tmatesoft.hg.internal.Patch;
-import org.tmatesoft.hg.repo.HgChangelog.ChangesetParser;
 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
 import org.tmatesoft.hg.util.Adaptable;
 import org.tmatesoft.hg.util.CancelledException;
 /**
 * @author TMate Software Ltd.
 */
 @Experimental(reason="API is not stable")
 public class HgBundle {
-	private final File bundleFile;
+	final File bundleFile;
 	private final DataAccessProvider accessProvider;
-	private final SessionContext ctx;
+	final SessionContext ctx;
 	private final EncodingHelper fnDecorer;
 	private Lifecycle.BasicCallback flowControl;
 	HgBundle(SessionContext sessionContext, DataAccessProvider dap, File bundle) {
 		ctx = sessionContext;
 	/**
 	 * Get changes recorded in the bundle that are missing from the supplied repository.
 	 * @param hgRepo repository that shall possess base revision for this bundle
 	 * @param inspector callback to get each changeset found
 	 */
-	public void changes(final HgRepository hgRepo, final HgChangelog.Inspector inspector) throws HgRuntimeException {
+	public void changes(final HgRepository hgRepo, final HgChangelog.Inspector inspector) throws HgIOException, HgRuntimeException {
 		Inspector bundleInsp = new Inspector() {
 			DigestHelper dh = new DigestHelper();
 			boolean emptyChangelog = true;
 			private DataAccess prevRevContent;
 			private int revisionIndex;
 			private ChangesetParser csetBuilder;
 			public void changelogStart() {
 				emptyChangelog = true;
 				revisionIndex = 0;
-				csetBuilder = new ChangesetParser(hgRepo, true);
+				csetBuilder = new ChangesetParser(hgRepo, new HgChangelog.RawCsetFactory(true));
 			}
 			public void changelogEnd() {
 				if (emptyChangelog) {
 					throw new IllegalStateException("No changelog group in the bundle"); // XXX perhaps, just be silent and/or log?
 a6f39e595b2b54f56304470269a936ead77f5725 9429c7bd1920fab164a9d2b621d38d57bcb49ae0 30bd389788464287cee22ccff54c330a4b715de5 a6f39e595b2b54f56304470269a936ead77f5725; patches:3
 fd4f2c98995beb051070630c272a9be87bef617d 30bd389788464287cee22ccff54c330a4b715de5 0000000000000000000000000000000000000000 fd4f2c98995beb051070630c272a9be87bef617d; patches:3
 To recreate 30bd..e5, one have to take content of 9429..e0, not its p1 f1db..5e
 */
-			public boolean element(GroupElement ge) throws HgRuntimeException {
+			public boolean element(GroupElement ge) throws IOException, HgRuntimeException {
 				emptyChangelog = false;
 				HgChangelog changelog = hgRepo.getChangelog();
 				try {
 					if (prevRevContent == null) {
 						if (ge.firstParent().isNull() && ge.secondParent().isNull()) {
 							// extra byte[] (inside ByteArrayChannel) duplication just for the sake of subsequent ByteArrayDataChannel wrap.
 							prevRevContent = new ByteArrayDataAccess(bac.toArray());
 						}
 					}
 					//
-					byte[] csetContent = ge.apply(prevRevContent);
+					byte[] csetContent = ge.patch().apply(prevRevContent, -1);
 					dh = dh.sha1(ge.firstParent(), ge.secondParent(), csetContent); // XXX ge may give me access to byte[] content of nodeid directly, perhaps, I don't need DH to be friend of Nodeid?
 					if (!ge.node().equalsTo(dh.asBinary())) {
 						throw new HgInvalidStateException(String.format("Integrity check failed on %s, node: %s", bundleFile, ge.node().shortNotation()));
 					}
-					ByteArrayDataAccess csetDataAccess = new ByteArrayDataAccess(csetContent);
+					RawChangeset cs = csetBuilder.parse(csetContent);
-					RawChangeset cs = csetBuilder.parse(csetDataAccess);
 					inspector.next(revisionIndex++, ge.node(), cs);
 					prevRevContent.done();
-					prevRevContent = csetDataAccess.reset();
+					prevRevContent = new ByteArrayDataAccess(csetContent);
 				} catch (CancelledException ex) {
 					return false;
-				} catch (IOException ex) {
-					throw new HgInvalidFileException("Invalid bundle file", ex, bundleFile); // TODO post-1.0 revisit exception handling
 				} catch (HgInvalidDataFormatException ex) {
 					throw new HgInvalidControlFileException("Invalid bundle file", ex, bundleFile);
 				}
 				return true;
 			}
 		void fileStart(String name) throws HgRuntimeException;
 		void fileEnd(String name) throws HgRuntimeException;
 		/**
-		 * XXX desperately need exceptions here
 		 * @param element data element, instance might be reused, don't keep a reference to it or its raw data
 		 * @return <code>true</code> to continue
-		 */
+		 * @throws IOException propagated exception from {@link GroupElement#data()}
-		boolean element(GroupElement element) throws HgRuntimeException;
+		 * @throws HgRuntimeException propagated exception (subclass thereof) to indicate issues with the library. <em>Runtime exception</em>
+		 */
+		boolean element(GroupElement element) throws IOException, HgRuntimeException;
 	}
 	/**
 	 * @param inspector callback to visit changelog entries
 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
 	 * @throws IllegalArgumentException if inspector argument is null
 	 */
-	public void inspectChangelog(Inspector inspector) throws HgRuntimeException {
+	public void inspectChangelog(Inspector inspector) throws HgIOException, HgRuntimeException {
 		if (inspector == null) {
 			throw new IllegalArgumentException();
 		}
 		final Lifecycle lifecycle = lifecycleSetUp(inspector);
 		DataAccess da = null;
 		try {
 			da = getDataStream();
 			internalInspectChangelog(da, inspector);
 		} catch (IOException ex) {
-			throw new HgInvalidFileException("Bundle.inspectChangelog failed", ex, bundleFile);
+			throw new HgIOException("Failed to inspect changelog in the bundle", ex, bundleFile);
 		} finally {
 			if (da != null) {
 				da.done();
 			}
 			lifecycleTearDown(lifecycle);
 	/**
 	 * @param inspector callback to visit manifest entries
 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
 	 * @throws IllegalArgumentException if inspector argument is null
 	 */
-	public void inspectManifest(Inspector inspector) throws HgRuntimeException {
+	public void inspectManifest(Inspector inspector) throws HgIOException, HgRuntimeException {
 		if (inspector == null) {
 			throw new IllegalArgumentException();
 		}
 		final Lifecycle lifecycle = lifecycleSetUp(inspector);
 		DataAccess da = null;
 				return;
 			}
 			skipGroup(da); // changelog
 			internalInspectManifest(da, inspector);
 		} catch (IOException ex) {
-			throw new HgInvalidFileException("Bundle.inspectManifest failed", ex, bundleFile);
+			throw new HgIOException("Failed to inspect manifest in the bundle", ex, bundleFile);
 		} finally {
 			if (da != null) {
 				da.done();
 			}
 			lifecycleTearDown(lifecycle);
 	/**
 	 * @param inspector callback to visit file entries
 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
 	 * @throws IllegalArgumentException if inspector argument is null
 	 */
-	public void inspectFiles(Inspector inspector) throws HgRuntimeException {
+	public void inspectFiles(Inspector inspector) throws HgIOException, HgRuntimeException {
 		if (inspector == null) {
 			throw new IllegalArgumentException();
 		}
 		final Lifecycle lifecycle = lifecycleSetUp(inspector);
 		DataAccess da = null;
 				return;
 			}
 			skipGroup(da); // manifest
 			internalInspectFiles(da, inspector);
 		} catch (IOException ex) {
-			throw new HgInvalidFileException("Bundle.inspectFiles failed", ex, bundleFile);
+			throw new HgIOException("Failed to inspect files in the bundle", ex, bundleFile);
 		} finally {
 			if (da != null) {
 				da.done();
 			}
 			lifecycleTearDown(lifecycle);
 	/**
 	 * @param inspector visit complete bundle (changelog, manifest and file entries)
 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
 	 * @throws IllegalArgumentException if inspector argument is null
 	 */
-	public void inspectAll(Inspector inspector) throws HgRuntimeException {
+	public void inspectAll(Inspector inspector) throws HgIOException, HgRuntimeException {
 		if (inspector == null) {
 			throw new IllegalArgumentException();
 		}
 		final Lifecycle lifecycle = lifecycleSetUp(inspector);
 		DataAccess da = null;
 			if (flowControl.isStopped()) {
 				return;
 			}
 			internalInspectFiles(da, inspector);
 		} catch (IOException ex) {
-			throw new HgInvalidFileException("Bundle.inspectAll failed", ex, bundleFile);
+			throw new HgIOException("Failed to inspect bundle", ex, bundleFile);
 		} finally {
 			if (da != null) {
 				da.done();
 			}
 			lifecycleTearDown(lifecycle);
 			da.skip(len - 4); // sizeof(int)
 			len = da.isEmpty() ? 0 : da.readInt();
 		}
 	}
-	@Experimental(reason="Cumbersome API, rawData and apply with byte[] perhaps need replacement with ByteChannel/ByteBuffer, and better Exceptions. Perhaps, shall split into interface and impl")
+	/**
-	public static class GroupElement {
+	 * Describes single element (a.k.a. chunk) of the group, either changelog, manifest or a file.
+	 */
+	public static final class GroupElement {
 		private final byte[] header; // byte[80] takes 120 bytes, 4 Nodeids - 192
 		private final DataAccess dataAccess;
+		private final Nodeid deltaBase;
 		private Patch patches;
-		private final Nodeid deltaBase;
 		GroupElement(byte[] fourNodeids, Nodeid deltaBaseRev, DataAccess rawDataAccess) {
 			assert fourNodeids != null && fourNodeids.length == 80;
 			header = fourNodeids;
 			deltaBase = deltaBaseRev;
 			dataAccess = rawDataAccess;
 		 */
 		public Nodeid patchBase() {
 			return deltaBase == null ? firstParent() : deltaBase;
 		}
-		public byte[] rawDataByteArray() throws IOException { // XXX IOException or HgInvalidFileException?
+		/**
-			return rawData().byteArray();
+		 * Read data of the group element.
-		}
+		 * Note, {@link InputStream streams} obtained from several calls to this method
+		 * can't be read simultaneously.
-		public byte[] apply(byte[] baseContent) throws IOException {
+		 *
-			return apply(new ByteArrayDataAccess(baseContent));
+		 * @return stream to access content of this group element, never <code>null</code>
-		}
+		 */
+		public InputStream data() {
-		/*package-local*/ DataAccess rawData() {
+			return new DataAccessInputStream(dataAccess);
-			return dataAccess;
 		}
 		/*package-local*/ Patch patch() throws IOException {
 			if (patches == null) {
 				dataAccess.reset();
 				patches.read(dataAccess);
 			}
 			return patches;
 		}
-		/*package-local*/ byte[] apply(DataAccess baseContent) throws IOException {
-			return patch().apply(baseContent, -1);
-		}
 		public String toString() {
 			int patchCount;
 			try {
 				patchCount = patch().count();
 			} catch (IOException ex) {
 				patchCount = -1;
 			}
 			return String.format("%s %s %s %s; patches:%d\n", node().shortNotation(), firstParent().shortNotation(), secondParent().shortNotation(), cset().shortNotation(), patchCount);
 		}
 	}
-	@Experimental(reason="Work in progress, not an API")
-	public class BundleSerializer implements DataSerializer.DataSource {
-		public void serialize(DataSerializer out) throws HgIOException, HgRuntimeException {
-			FileInputStream fis = null;
-			try {
-				fis = new FileInputStream(HgBundle.this.bundleFile);
-				byte[] buffer = new byte[8*1024];
-				int r;
-				while ((r = fis.read(buffer, 0, buffer.length)) > 0) {
-					out.write(buffer, 0, r);
-				}
-			} catch (IOException ex) {
-				throw new HgIOException("Failed to serialize bundle", HgBundle.this.bundleFile);
-			} finally {
-				new FileUtils(HgBundle.this.ctx.getLog(), this).closeQuietly(fis, HgBundle.this.bundleFile);
-			}
-		}
-		public int serializeLength() throws HgRuntimeException {
-			return Internals.ltoi(HgBundle.this.bundleFile.length());
-		}
-	}
 }

Mercurial > hg4j

comparison src/org/tmatesoft/hg/repo/HgBundle.java @ 673:545b1d4cc11d