tikhomirov@17: /* tikhomirov@74: * Copyright (c) 2010-2011 TMate Software Ltd tikhomirov@74: * tikhomirov@74: * This program is free software; you can redistribute it and/or modify tikhomirov@74: * it under the terms of the GNU General Public License as published by tikhomirov@74: * the Free Software Foundation; version 2 of the License. tikhomirov@74: * tikhomirov@74: * This program is distributed in the hope that it will be useful, tikhomirov@74: * but WITHOUT ANY WARRANTY; without even the implied warranty of tikhomirov@74: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the tikhomirov@74: * GNU General Public License for more details. tikhomirov@74: * tikhomirov@74: * For information on how to redistribute this software under tikhomirov@74: * the terms of a license other than GNU General Public License tikhomirov@102: * contact TMate Software at support@hg4j.com tikhomirov@2: */ tikhomirov@74: package org.tmatesoft.hg.repo; tikhomirov@2: tikhomirov@148: import static org.tmatesoft.hg.repo.HgInternals.wrongLocalRevision; tikhomirov@148: import static org.tmatesoft.hg.repo.HgRepository.*; tikhomirov@74: tikhomirov@157: import java.io.ByteArrayOutputStream; tikhomirov@237: import java.io.File; tikhomirov@237: import java.io.FileInputStream; tikhomirov@148: import java.io.IOException; tikhomirov@115: import java.nio.ByteBuffer; tikhomirov@237: import java.nio.channels.FileChannel; tikhomirov@78: import java.util.ArrayList; tikhomirov@240: import java.util.Arrays; tikhomirov@78: import java.util.Collection; tikhomirov@305: import java.util.Collections; tikhomirov@305: import java.util.List; tikhomirov@78: tikhomirov@148: import org.tmatesoft.hg.core.HgDataStreamException; tikhomirov@157: import org.tmatesoft.hg.core.HgException; tikhomirov@74: import org.tmatesoft.hg.core.Nodeid; tikhomirov@157: import org.tmatesoft.hg.internal.DataAccess; tikhomirov@121: import org.tmatesoft.hg.internal.FilterByteChannel; tikhomirov@277: import org.tmatesoft.hg.internal.FilterDataAccess; tikhomirov@276: import org.tmatesoft.hg.internal.IntMap; tikhomirov@77: import org.tmatesoft.hg.internal.RevlogStream; tikhomirov@115: import org.tmatesoft.hg.util.ByteChannel; tikhomirov@237: import org.tmatesoft.hg.util.CancelSupport; tikhomirov@148: import org.tmatesoft.hg.util.CancelledException; tikhomirov@305: import org.tmatesoft.hg.util.Pair; tikhomirov@133: import org.tmatesoft.hg.util.Path; tikhomirov@237: import org.tmatesoft.hg.util.ProgressSupport; tikhomirov@74: tikhomirov@5: tikhomirov@17: tikhomirov@2: /** tikhomirov@2: * ? name:HgFileNode? tikhomirov@74: * tikhomirov@74: * @author Artem Tikhomirov tikhomirov@74: * @author TMate Software Ltd. tikhomirov@2: */ tikhomirov@2: public class HgDataFile extends Revlog { tikhomirov@2: tikhomirov@3: // absolute from repo root? tikhomirov@3: // slashes, unix-style? tikhomirov@3: // repo location agnostic, just to give info to user, not to access real storage tikhomirov@74: private final Path path; tikhomirov@134: private Metadata metadata; // get initialized on first access to file content. tikhomirov@2: tikhomirov@115: /*package-local*/HgDataFile(HgRepository hgRepo, Path filePath, RevlogStream content) { tikhomirov@21: super(hgRepo, content); tikhomirov@115: path = filePath; tikhomirov@3: } tikhomirov@115: tikhomirov@115: /*package-local*/HgDataFile(HgRepository hgRepo, Path filePath) { tikhomirov@115: super(hgRepo); tikhomirov@115: path = filePath; tikhomirov@115: } tikhomirov@115: tikhomirov@115: // exists is not the best name possible. now it means no file with such name was ever known to the repo. tikhomirov@115: // it might be confused with files existed before but lately removed. tikhomirov@3: public boolean exists() { tikhomirov@3: return content != null; // XXX need better impl tikhomirov@2: } tikhomirov@2: tikhomirov@77: // human-readable (i.e. "COPYING", not "store/data/_c_o_p_y_i_n_g.i") tikhomirov@74: public Path getPath() { tikhomirov@157: return path; // hgRepo.backresolve(this) -> name? In this case, what about hashed long names? tikhomirov@2: } tikhomirov@2: tikhomirov@275: /** tikhomirov@275: * @return size of the file content at the given revision tikhomirov@275: */ tikhomirov@275: public int length(Nodeid nodeid) throws HgDataStreamException { tikhomirov@275: return length(getLocalRevision(nodeid)); tikhomirov@275: tikhomirov@275: } tikhomirov@275: tikhomirov@275: /** tikhomirov@275: * @return size of the file content at the revision identified by local revision number. tikhomirov@275: */ tikhomirov@275: public int length(int localRev) throws HgDataStreamException { tikhomirov@275: if (metadata == null || !metadata.checked(localRev)) { tikhomirov@275: checkAndRecordMetadata(localRev); tikhomirov@275: } tikhomirov@275: final int dataLen = content.dataLength(localRev); tikhomirov@275: if (metadata.known(localRev)) { tikhomirov@275: return dataLen - metadata.dataOffset(localRev); tikhomirov@275: } tikhomirov@275: return dataLen; tikhomirov@22: } tikhomirov@22: tikhomirov@237: /** tikhomirov@237: * Reads content of the file from working directory. If file present in the working directory, its actual content without tikhomirov@237: * any filters is supplied through the sink. If file does not exist in the working dir, this method provides content of a file tikhomirov@237: * as if it would be refreshed in the working copy, i.e. its corresponding revision tikhomirov@237: * (XXX according to dirstate? file tip?) is read from the repository, and filters repo -> working copy get applied. tikhomirov@237: * tikhomirov@237: * @param sink where to pipe content to tikhomirov@237: * @throws HgDataStreamException to indicate troubles reading repository file tikhomirov@237: * @throws CancelledException if operation was cancelled tikhomirov@237: */ tikhomirov@237: public void workingCopy(ByteChannel sink) throws HgDataStreamException, CancelledException { tikhomirov@237: File f = getRepo().getFile(this); tikhomirov@237: if (f.exists()) { tikhomirov@237: final CancelSupport cs = CancelSupport.Factory.get(sink); tikhomirov@237: final ProgressSupport progress = ProgressSupport.Factory.get(sink); tikhomirov@237: final long flength = f.length(); tikhomirov@237: final int bsize = (int) Math.min(flength, 32*1024); tikhomirov@237: progress.start((int) (flength > Integer.MAX_VALUE ? flength >>> 15 /*32 kb buf size*/ : flength)); tikhomirov@237: ByteBuffer buf = ByteBuffer.allocate(bsize); tikhomirov@237: FileChannel fc = null; tikhomirov@237: try { tikhomirov@237: fc = new FileInputStream(f).getChannel(); tikhomirov@237: while (fc.read(buf) != -1) { tikhomirov@237: cs.checkCancelled(); tikhomirov@237: buf.flip(); tikhomirov@237: int consumed = sink.write(buf); tikhomirov@237: progress.worked(flength > Integer.MAX_VALUE ? 1 : consumed); tikhomirov@237: buf.compact(); tikhomirov@237: } tikhomirov@237: } catch (IOException ex) { tikhomirov@237: throw new HgDataStreamException(getPath(), ex); tikhomirov@237: } finally { tikhomirov@237: progress.done(); tikhomirov@237: if (fc != null) { tikhomirov@237: try { tikhomirov@237: fc.close(); tikhomirov@237: } catch (IOException ex) { tikhomirov@295: getRepo().getContext().getLog().info(getClass(), ex, null); tikhomirov@237: } tikhomirov@237: } tikhomirov@237: } tikhomirov@237: } else { tikhomirov@237: contentWithFilters(TIP, sink); tikhomirov@237: } tikhomirov@2: } tikhomirov@115: tikhomirov@157: // public void content(int revision, ByteChannel sink, boolean applyFilters) throws HgDataStreamException, IOException, CancelledException { tikhomirov@157: // byte[] content = content(revision); tikhomirov@157: // final CancelSupport cancelSupport = CancelSupport.Factory.get(sink); tikhomirov@157: // final ProgressSupport progressSupport = ProgressSupport.Factory.get(sink); tikhomirov@157: // ByteBuffer buf = ByteBuffer.allocate(512); tikhomirov@157: // int left = content.length; tikhomirov@157: // progressSupport.start(left); tikhomirov@157: // int offset = 0; tikhomirov@157: // cancelSupport.checkCancelled(); tikhomirov@157: // ByteChannel _sink = applyFilters ? new FilterByteChannel(sink, getRepo().getFiltersFromRepoToWorkingDir(getPath())) : sink; tikhomirov@157: // do { tikhomirov@157: // buf.put(content, offset, Math.min(left, buf.remaining())); tikhomirov@157: // buf.flip(); tikhomirov@157: // cancelSupport.checkCancelled(); tikhomirov@157: // // XXX I may not rely on returned number of bytes but track change in buf position instead. tikhomirov@157: // int consumed = _sink.write(buf); tikhomirov@157: // buf.compact(); tikhomirov@157: // offset += consumed; tikhomirov@157: // left -= consumed; tikhomirov@157: // progressSupport.worked(consumed); tikhomirov@157: // } while (left > 0); tikhomirov@157: // progressSupport.done(); // XXX shall specify whether #done() is invoked always or only if completed successfully. tikhomirov@157: // } tikhomirov@157: tikhomirov@157: /*XXX not sure distinct method contentWithFilters() is the best way to do, perhaps, callers shall add filters themselves?*/ tikhomirov@237: public void contentWithFilters(int revision, ByteChannel sink) throws HgDataStreamException, CancelledException { tikhomirov@237: if (revision == WORKING_COPY) { tikhomirov@237: workingCopy(sink); // pass un-mangled sink tikhomirov@237: } else { tikhomirov@237: content(revision, new FilterByteChannel(sink, getRepo().getFiltersFromRepoToWorkingDir(getPath()))); tikhomirov@237: } tikhomirov@115: } tikhomirov@22: tikhomirov@78: // for data files need to check heading of the file content for possible metadata tikhomirov@78: // @see http://mercurial.selenic.com/wiki/FileFormats#data.2BAC8- tikhomirov@237: public void content(int revision, ByteChannel sink) throws HgDataStreamException, CancelledException { tikhomirov@78: if (revision == TIP) { tikhomirov@135: revision = getLastRevision(); tikhomirov@78: } tikhomirov@157: if (revision == WORKING_COPY) { tikhomirov@237: // sink is supposed to come into workingCopy without filters tikhomirov@237: // thus we shall not get here (into #content) from #contentWithFilters(WC) tikhomirov@157: workingCopy(sink); tikhomirov@157: return; tikhomirov@157: } tikhomirov@157: if (wrongLocalRevision(revision) || revision == BAD_REVISION) { tikhomirov@148: throw new IllegalArgumentException(String.valueOf(revision)); tikhomirov@148: } tikhomirov@157: if (sink == null) { tikhomirov@157: throw new IllegalArgumentException(); tikhomirov@157: } tikhomirov@134: if (metadata == null) { tikhomirov@134: metadata = new Metadata(); tikhomirov@134: } tikhomirov@277: ErrorHandlingInspector insp; tikhomirov@134: if (metadata.none(revision)) { tikhomirov@157: insp = new ContentPipe(sink, 0); tikhomirov@157: } else if (metadata.known(revision)) { tikhomirov@157: insp = new ContentPipe(sink, metadata.dataOffset(revision)); tikhomirov@157: } else { tikhomirov@157: // do not know if there's metadata tikhomirov@277: insp = new MetadataInspector(metadata, getPath(), new ContentPipe(sink, 0)); tikhomirov@78: } tikhomirov@157: insp.checkCancelled(); tikhomirov@157: super.content.iterate(revision, revision, true, insp); tikhomirov@157: try { tikhomirov@237: insp.checkFailed(); // XXX is there real need to throw IOException from ContentPipe? tikhomirov@157: } catch (HgDataStreamException ex) { tikhomirov@157: throw ex; tikhomirov@237: } catch (IOException ex) { tikhomirov@237: throw new HgDataStreamException(getPath(), ex); tikhomirov@157: } catch (HgException ex) { tikhomirov@157: // shall not happen, unless we changed ContentPipe or its subclass tikhomirov@215: throw new HgDataStreamException(getPath(), ex.getClass().getName(), ex); tikhomirov@78: } tikhomirov@78: } tikhomirov@157: tikhomirov@317: private static class HistoryNode { tikhomirov@317: int changeset; tikhomirov@317: Nodeid cset; tikhomirov@317: HistoryNode parent1, parent2; tikhomirov@317: List children; tikhomirov@317: tikhomirov@317: HistoryNode(int cs, HistoryNode p1, HistoryNode p2) { tikhomirov@317: changeset = cs; tikhomirov@317: parent1 = p1; tikhomirov@317: parent2 = p2; tikhomirov@317: if (p1 != null) { tikhomirov@317: p1.addChild(this); tikhomirov@317: } tikhomirov@317: if (p2 != null) { tikhomirov@317: p2.addChild(this); tikhomirov@317: } tikhomirov@317: } tikhomirov@317: tikhomirov@317: Nodeid changesetRevision() { tikhomirov@317: assert cset != null : "we initialize all csets prior to use"; tikhomirov@317: return cset; tikhomirov@317: } tikhomirov@317: tikhomirov@317: void addChild(HistoryNode child) { tikhomirov@317: if (children == null) { tikhomirov@317: children = new ArrayList(2); tikhomirov@317: } tikhomirov@317: children.add(child); tikhomirov@317: } tikhomirov@305: } tikhomirov@305: tikhomirov@317: public void history(HgChangelog.TreeInspector inspector) { tikhomirov@317: final CancelSupport cancelSupport = CancelSupport.Factory.get(inspector); tikhomirov@317: try { tikhomirov@317: final boolean[] needsSorting = { false }; tikhomirov@317: final HistoryNode[] completeHistory = new HistoryNode[getRevisionCount()]; tikhomirov@317: final int[] commitRevisions = new int[completeHistory.length]; tikhomirov@317: RevlogStream.Inspector insp = new RevlogStream.Inspector() { tikhomirov@317: public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { tikhomirov@317: if (revisionNumber > 0) { tikhomirov@317: if (commitRevisions[revisionNumber-1] > linkRevision) { tikhomirov@317: needsSorting[0] = true; tikhomirov@317: } tikhomirov@317: } tikhomirov@317: commitRevisions[revisionNumber] = linkRevision; tikhomirov@317: HistoryNode p1 = null, p2 = null; tikhomirov@317: if (parent1Revision != -1) { tikhomirov@317: p1 = completeHistory[parent1Revision]; tikhomirov@317: } tikhomirov@317: if (parent2Revision != -1) { tikhomirov@317: p2 = completeHistory[parent2Revision]; tikhomirov@317: } tikhomirov@317: completeHistory[revisionNumber] = new HistoryNode(linkRevision, p1, p2); tikhomirov@305: } tikhomirov@317: }; tikhomirov@317: content.iterate(0, getLastRevision(), false, insp); tikhomirov@317: cancelSupport.checkCancelled(); tikhomirov@317: if (needsSorting[0]) { tikhomirov@317: Arrays.sort(commitRevisions); tikhomirov@317: } tikhomirov@317: // read changeset revisions at once (to avoid numerous changelog.getRevision reads) tikhomirov@317: // but just nodeids, not RawChangeset (changelog.iterate(data=false) tikhomirov@317: ArrayList changesetRevisions = new ArrayList(commitRevisions.length); tikhomirov@317: getRepo().getChangelog().getRevisionsInternal(changesetRevisions, commitRevisions); tikhomirov@317: cancelSupport.checkCancelled(); tikhomirov@317: // assign them to corresponding HistoryNodes tikhomirov@317: for (int i = 0; i < completeHistory.length; i++ ) { tikhomirov@317: final HistoryNode n = completeHistory[i]; tikhomirov@317: if (needsSorting[0]) { tikhomirov@317: int x = Arrays.binarySearch(commitRevisions, n.changeset); tikhomirov@317: assert x >= 0; tikhomirov@317: n.cset = changesetRevisions.get(x); tikhomirov@317: } else { tikhomirov@317: // commit revisions were not sorted, may use original index directly tikhomirov@317: n.cset = changesetRevisions.get(i); tikhomirov@305: } tikhomirov@305: } tikhomirov@317: cancelSupport.checkCancelled(); tikhomirov@317: // XXX shall sort completeHistory according to changeset numbers? tikhomirov@317: for (int i = 0; i < completeHistory.length; i++ ) { tikhomirov@317: final HistoryNode n = completeHistory[i]; tikhomirov@305: HistoryNode p; tikhomirov@305: Nodeid p1, p2; tikhomirov@317: if ((p = n.parent1) != null) { tikhomirov@305: p1 = p.changesetRevision(); tikhomirov@305: } else { tikhomirov@305: p1 = Nodeid.NULL; tikhomirov@305: } tikhomirov@317: if ((p= n.parent2) != null) { tikhomirov@305: p2 = p.changesetRevision(); tikhomirov@305: } else { tikhomirov@305: p2 = Nodeid.NULL; tikhomirov@305: } tikhomirov@317: final Pair parentChangesets = new Pair(p1, p2); tikhomirov@317: final List childChangesets; tikhomirov@305: if (n.children == null) { tikhomirov@317: childChangesets = Collections.emptyList(); tikhomirov@317: } else { tikhomirov@317: Nodeid[] revisions = new Nodeid[n.children.size()]; tikhomirov@317: int j = 0; tikhomirov@317: for (HistoryNode hn : n.children) { tikhomirov@317: revisions[j++] = hn.changesetRevision(); tikhomirov@317: } tikhomirov@317: childChangesets = Arrays.asList(revisions); tikhomirov@305: } tikhomirov@317: inspector.next(n.changesetRevision(), parentChangesets, childChangesets); tikhomirov@317: cancelSupport.checkCancelled(); tikhomirov@305: } tikhomirov@317: } catch (CancelledException ex) { tikhomirov@317: return; tikhomirov@317: } tikhomirov@305: } tikhomirov@305: tikhomirov@129: public void history(HgChangelog.Inspector inspector) { tikhomirov@135: history(0, getLastRevision(), inspector); tikhomirov@48: } tikhomirov@48: tikhomirov@129: public void history(int start, int end, HgChangelog.Inspector inspector) { tikhomirov@3: if (!exists()) { tikhomirov@3: throw new IllegalStateException("Can't get history of invalid repository file node"); tikhomirov@3: } tikhomirov@135: final int last = getLastRevision(); tikhomirov@77: if (end == TIP) { tikhomirov@77: end = last; tikhomirov@77: } tikhomirov@300: if (start == TIP) { tikhomirov@300: start = last; tikhomirov@300: } tikhomirov@300: HgInternals.checkRevlogRange(start, end, last); tikhomirov@300: tikhomirov@48: final int[] commitRevisions = new int[end - start + 1]; tikhomirov@242: final boolean[] needsSorting = { false }; tikhomirov@77: RevlogStream.Inspector insp = new RevlogStream.Inspector() { tikhomirov@3: int count = 0; tikhomirov@51: public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { tikhomirov@242: if (count > 0) { tikhomirov@242: if (commitRevisions[count -1] > linkRevision) { tikhomirov@242: needsSorting[0] = true; tikhomirov@242: } tikhomirov@242: } tikhomirov@3: commitRevisions[count++] = linkRevision; tikhomirov@3: } tikhomirov@3: }; tikhomirov@48: content.iterate(start, end, false, insp); tikhomirov@233: final HgChangelog changelog = getRepo().getChangelog(); tikhomirov@242: if (needsSorting[0]) { tikhomirov@242: // automatic tools (svnmerge?) produce unnatural file history tikhomirov@242: // (e.g. cpython/Lib/doctest.py, revision 164 points to cset 63509, 165 - to 38453) tikhomirov@242: Arrays.sort(commitRevisions); tikhomirov@233: } tikhomirov@245: changelog.rangeInternal(inspector, commitRevisions); tikhomirov@3: } tikhomirov@88: tikhomirov@88: // for a given local revision of the file, find out local revision in the changelog tikhomirov@88: public int getChangesetLocalRevision(int revision) { tikhomirov@88: return content.linkRevision(revision); tikhomirov@88: } tikhomirov@88: tikhomirov@88: public Nodeid getChangesetRevision(Nodeid nid) { tikhomirov@88: int changelogRevision = getChangesetLocalRevision(getLocalRevision(nid)); tikhomirov@88: return getRepo().getChangelog().getRevision(changelogRevision); tikhomirov@88: } tikhomirov@78: tikhomirov@157: public boolean isCopy() throws HgDataStreamException { tikhomirov@134: if (metadata == null || !metadata.checked(0)) { tikhomirov@275: checkAndRecordMetadata(0); tikhomirov@78: } tikhomirov@134: if (!metadata.known(0)) { tikhomirov@78: return false; tikhomirov@78: } tikhomirov@78: return metadata.find(0, "copy") != null; tikhomirov@78: } tikhomirov@78: tikhomirov@157: public Path getCopySourceName() throws HgDataStreamException { tikhomirov@78: if (isCopy()) { tikhomirov@78: return Path.create(metadata.find(0, "copy")); tikhomirov@78: } tikhomirov@78: throw new UnsupportedOperationException(); // XXX REVISIT, think over if Exception is good (clients would check isCopy() anyway, perhaps null is sufficient?) tikhomirov@78: } tikhomirov@78: tikhomirov@157: public Nodeid getCopySourceRevision() throws HgDataStreamException { tikhomirov@78: if (isCopy()) { tikhomirov@78: return Nodeid.fromAscii(metadata.find(0, "copyrev")); // XXX reuse/cache Nodeid tikhomirov@78: } tikhomirov@78: throw new UnsupportedOperationException(); tikhomirov@78: } tikhomirov@88: tikhomirov@88: @Override tikhomirov@88: public String toString() { tikhomirov@88: StringBuilder sb = new StringBuilder(getClass().getSimpleName()); tikhomirov@88: sb.append('('); tikhomirov@88: sb.append(getPath()); tikhomirov@88: sb.append(')'); tikhomirov@88: return sb.toString(); tikhomirov@88: } tikhomirov@275: tikhomirov@275: private void checkAndRecordMetadata(int localRev) throws HgDataStreamException { tikhomirov@275: // content() always initializes metadata. tikhomirov@275: // FIXME this is expensive way to find out metadata, distinct RevlogStream.Iterator would be better. tikhomirov@275: // Alternatively, may parameterize MetadataContentPipe to do prepare only. tikhomirov@275: // For reference, when throwing CancelledException, hg status -A --rev 3:80 takes 70 ms tikhomirov@275: // however, if we just consume buffer instead (buffer.position(buffer.limit()), same command takes ~320ms tikhomirov@275: // (compared to command-line counterpart of 190ms) tikhomirov@275: try { tikhomirov@275: content(localRev, new ByteChannel() { // No-op channel tikhomirov@275: public int write(ByteBuffer buffer) throws IOException, CancelledException { tikhomirov@275: throw new CancelledException(); tikhomirov@275: } tikhomirov@275: }); tikhomirov@275: } catch (CancelledException ex) { tikhomirov@275: // it's ok, we did that tikhomirov@275: } catch (Exception ex) { tikhomirov@275: throw new HgDataStreamException(getPath(), "Can't initialize metadata", ex).setRevisionNumber(localRev); tikhomirov@275: } tikhomirov@275: } tikhomirov@78: tikhomirov@88: private static final class MetadataEntry { tikhomirov@78: private final String entry; tikhomirov@78: private final int valueStart; tikhomirov@78: /*package-local*/MetadataEntry(String key, String value) { tikhomirov@78: entry = key + value; tikhomirov@78: valueStart = key.length(); tikhomirov@78: } tikhomirov@78: /*package-local*/boolean matchKey(String key) { tikhomirov@78: return key.length() == valueStart && entry.startsWith(key); tikhomirov@78: } tikhomirov@134: // uncomment once/if needed tikhomirov@134: // public String key() { tikhomirov@134: // return entry.substring(0, valueStart); tikhomirov@134: // } tikhomirov@78: public String value() { tikhomirov@78: return entry.substring(valueStart); tikhomirov@78: } tikhomirov@78: } tikhomirov@78: tikhomirov@78: private static class Metadata { tikhomirov@276: private static class Record { tikhomirov@276: public final int offset; tikhomirov@276: public final MetadataEntry[] entries; tikhomirov@276: tikhomirov@276: public Record(int off, MetadataEntry[] entr) { tikhomirov@276: offset = off; tikhomirov@276: entries = entr; tikhomirov@276: } tikhomirov@276: } tikhomirov@78: // XXX sparse array needed tikhomirov@276: private final IntMap entries = new IntMap(5); tikhomirov@134: tikhomirov@276: private final Record NONE = new Record(-1, null); // don't want statics tikhomirov@134: tikhomirov@134: // true when there's metadata for given revision tikhomirov@78: boolean known(int revision) { tikhomirov@276: Record i = entries.get(revision); tikhomirov@134: return i != null && NONE != i; tikhomirov@134: } tikhomirov@134: tikhomirov@134: // true when revision has been checked for metadata presence. tikhomirov@134: public boolean checked(int revision) { tikhomirov@276: return entries.containsKey(revision); tikhomirov@78: } tikhomirov@134: tikhomirov@134: // true when revision has been checked and found not having any metadata tikhomirov@134: boolean none(int revision) { tikhomirov@276: Record i = entries.get(revision); tikhomirov@134: return i == NONE; tikhomirov@134: } tikhomirov@134: tikhomirov@134: // mark revision as having no metadata. tikhomirov@134: void recordNone(int revision) { tikhomirov@276: Record i = entries.get(revision); tikhomirov@134: if (i == NONE) { tikhomirov@134: return; // already there tikhomirov@134: } tikhomirov@134: if (i != null) { tikhomirov@134: throw new IllegalStateException(String.format("Trying to override Metadata state for revision %d (known offset: %d)", revision, i)); tikhomirov@134: } tikhomirov@276: entries.put(revision, NONE); tikhomirov@134: } tikhomirov@134: tikhomirov@78: // since this is internal class, callers are supposed to ensure arg correctness (i.e. ask known() before) tikhomirov@78: int dataOffset(int revision) { tikhomirov@276: return entries.get(revision).offset; tikhomirov@78: } tikhomirov@78: void add(int revision, int dataOffset, Collection e) { tikhomirov@276: assert !entries.containsKey(revision); tikhomirov@276: entries.put(revision, new Record(dataOffset, e.toArray(new MetadataEntry[e.size()]))); tikhomirov@78: } tikhomirov@276: tikhomirov@78: String find(int revision, String key) { tikhomirov@276: for (MetadataEntry me : entries.get(revision).entries) { tikhomirov@78: if (me.matchKey(key)) { tikhomirov@78: return me.value(); tikhomirov@78: } tikhomirov@78: } tikhomirov@78: return null; tikhomirov@78: } tikhomirov@78: } tikhomirov@157: tikhomirov@277: private static class MetadataInspector extends ErrorHandlingInspector implements RevlogStream.Inspector { tikhomirov@157: private final Metadata metadata; tikhomirov@215: private final Path fname; // need this only for error reporting tikhomirov@277: private final RevlogStream.Inspector delegate; tikhomirov@157: tikhomirov@277: public MetadataInspector(Metadata _metadata, Path file, RevlogStream.Inspector chain) { tikhomirov@157: metadata = _metadata; tikhomirov@215: fname = file; tikhomirov@277: delegate = chain; tikhomirov@277: setCancelSupport(CancelSupport.Factory.get(chain)); tikhomirov@157: } tikhomirov@157: tikhomirov@277: public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { tikhomirov@277: try { tikhomirov@277: final int daLength = data.length(); tikhomirov@277: if (daLength < 4 || data.readByte() != 1 || data.readByte() != 10) { tikhomirov@277: metadata.recordNone(revisionNumber); tikhomirov@277: data.reset(); tikhomirov@277: } else { tikhomirov@277: ArrayList _metadata = new ArrayList(); tikhomirov@277: int offset = parseMetadata(data, daLength, _metadata); tikhomirov@277: metadata.add(revisionNumber, offset, _metadata); tikhomirov@277: // da is in prepared state (i.e. we consumed all bytes up to metadata end). tikhomirov@277: // However, it's not safe to assume delegate won't call da.reset() for some reason, tikhomirov@277: // and we need to ensure predictable result. tikhomirov@277: data.reset(); tikhomirov@277: data = new FilterDataAccess(data, offset, daLength - offset); tikhomirov@277: } tikhomirov@277: if (delegate != null) { tikhomirov@277: delegate.next(revisionNumber, actualLen, baseRevision, linkRevision, parent1Revision, parent2Revision, nodeid, data); tikhomirov@277: } tikhomirov@277: } catch (IOException ex) { tikhomirov@277: recordFailure(ex); tikhomirov@277: } catch (HgDataStreamException ex) { tikhomirov@277: recordFailure(ex.setRevisionNumber(revisionNumber)); tikhomirov@157: } tikhomirov@277: } tikhomirov@277: tikhomirov@277: private int parseMetadata(DataAccess data, final int daLength, ArrayList _metadata) throws IOException, HgDataStreamException { tikhomirov@157: int lastEntryStart = 2; tikhomirov@157: int lastColon = -1; tikhomirov@157: // XXX in fact, need smth like ByteArrayBuilder, similar to StringBuilder, tikhomirov@157: // which can't be used here because we can't convert bytes to chars as we read them tikhomirov@157: // (there might be multi-byte encoding), and we need to collect all bytes before converting to string tikhomirov@157: ByteArrayOutputStream bos = new ByteArrayOutputStream(); tikhomirov@157: String key = null, value = null; tikhomirov@157: boolean byteOne = false; tikhomirov@157: for (int i = 2; i < daLength; i++) { tikhomirov@277: byte b = data.readByte(); tikhomirov@157: if (b == '\n') { tikhomirov@157: if (byteOne) { // i.e. \n follows 1 tikhomirov@157: lastEntryStart = i+1; tikhomirov@157: // XXX is it possible to have here incomplete key/value (i.e. if last pair didn't end with \n) tikhomirov@157: break; tikhomirov@157: } tikhomirov@157: if (key == null || lastColon == -1 || i <= lastColon) { tikhomirov@157: throw new IllegalStateException(); // FIXME log instead and record null key in the metadata. Ex just to fail fast during dev tikhomirov@157: } tikhomirov@157: value = new String(bos.toByteArray()).trim(); tikhomirov@157: bos.reset(); tikhomirov@157: _metadata.add(new MetadataEntry(key, value)); tikhomirov@157: key = value = null; tikhomirov@157: lastColon = -1; tikhomirov@157: lastEntryStart = i+1; tikhomirov@157: continue; tikhomirov@157: } tikhomirov@277: // byteOne has to be consumed up to this line, if not yet, consume it tikhomirov@157: if (byteOne) { tikhomirov@157: // insert 1 we've read on previous step into the byte builder tikhomirov@157: bos.write(1); tikhomirov@277: byteOne = false; tikhomirov@157: // fall-through to consume current byte tikhomirov@157: } tikhomirov@157: if (b == (int) ':') { tikhomirov@157: assert value == null; tikhomirov@157: key = new String(bos.toByteArray()); tikhomirov@157: bos.reset(); tikhomirov@157: lastColon = i; tikhomirov@157: } else if (b == 1) { tikhomirov@157: byteOne = true; tikhomirov@157: } else { tikhomirov@157: bos.write(b); tikhomirov@157: } tikhomirov@157: } tikhomirov@277: if (data.isEmpty() || !byteOne) { tikhomirov@277: throw new HgDataStreamException(fname, "Metadata is not closed properly", null); tikhomirov@157: } tikhomirov@277: return lastEntryStart; tikhomirov@17: } tikhomirov@322: tikhomirov@322: @Override tikhomirov@322: public void checkFailed() throws HgException, IOException, CancelledException { tikhomirov@322: super.checkFailed(); tikhomirov@322: if (delegate instanceof ErrorHandlingInspector) { tikhomirov@322: // XXX need to add ErrorDestination and pass it around (much like CancelSupport get passed) tikhomirov@322: // so that delegate would be able report its failures directly to caller without this hack tikhomirov@322: ((ErrorHandlingInspector) delegate).checkFailed(); tikhomirov@322: } tikhomirov@322: } tikhomirov@17: } tikhomirov@2: }