public HgRevlogWriter(HgRevlog revlog, HgFileSystem fileSystem)
{
this.revlog = revlog;
this.fileSystem = fileSystem;
revlogReader = new HgRevlogReader(revlog, fileSystem);
}
public HgRevlogBasedStorage(HgRevlog revlog, HgRevlogReader revlogReader)
{
log = LogManager.GetLogger(GetType().FullName);
Revlog = revlog;
this.revlogReader = revlogReader;
}
public HgLargefilesEnabledRevlog(HgRevlog standinRevlog, HgRevlogReader standinRevlogReader, string storeBasePath) :
base(standinRevlog.IndexPath, standinRevlog.DataPath, standinRevlog.Version, standinRevlog.InlineData, standinRevlog.Entries)
{
this.standinRevlog = standinRevlog;
this.standinRevlogReader = standinRevlogReader;
this.storeBasePath = storeBasePath;
}
public override HgFilelog GetFilelog(HgPath hgPath)
{
var hglfPath = HgPath.Combine(".hglf", hgPath);
var standinFilelog = underlyingStore.GetFilelog(hglfPath);
if(standinFilelog == null) return underlyingStore.GetFilelog(hgPath);
var standinRevlogReader = new HgRevlogReader(standinFilelog.Revlog, FileSystem);
var largefileRevlog = new HgLargefilesEnabledRevlog(standinFilelog.Revlog, standinRevlogReader, StoreBasePath);
standinFilelog = new HgLargefilesEnabledFilelog(largefileRevlog, hglfPath, standinRevlogReader);
return standinFilelog;
}
private void VerifyChangelog(IDictionary<HgNodeID, IList<UInt32>> manifestLinkrevs, IDictionary<string, IList<uint>> fileLinkrevs)
{
VerifyRevlog(repository.Changelog.Revlog);
var hgChangelogReader = new HgChangelogReader(repository.Encoder);
foreach(var hgChangelogEntry in repository.Changelog.Revlog.Entries)
{
//VerifyRevlogEntry(hgChangelogEntry);
var hgEntry = new HgRevlogReader(repository.Changelog.Revlog, fileSystem).ReadRevlogEntry(hgChangelogEntry.Revision);
var hgChangeset = hgChangelogReader.ReadChangeset(hgEntry);
manifestLinkrevs[hgChangeset.ManifestNodeID].Add(hgChangelogEntry.Revision);
foreach(var file in hgChangeset.Files)
fileLinkrevs[file].Add(hgChangelogEntry.Revision);
} // foreach
}
private void VerifyManifest(IDictionary<HgNodeID, IList<uint>> manifestLinkrevs, IDictionary<string, IDictionary<HgNodeID, UInt32>> fileNodeIDs)
{
var hgManifestReader = new HgManifestReader(repository.Encoder);
foreach(var hgManifestEntry in repository.Manifest.Revlog.Entries)
{
var hgEntry = new HgRevlogReader(repository.Manifest.Revlog, fileSystem).ReadRevlogEntry(hgManifestEntry.Revision);
var hgManifest = hgManifestReader.ReadManifestEntry(hgEntry);
if(!manifestLinkrevs[hgManifestEntry.NodeID].Any())
throw new Exception(hgManifestEntry.NodeID.Short + " not in changesets");
manifestLinkrevs.Remove(hgManifestEntry.NodeID);
foreach(var hgManifestFileEntry in hgManifest.Files)
{
fileNodeIDs[hgManifestFileEntry.Path.FullPath][hgManifestFileEntry.FilelogNodeID] = hgManifestEntry.LinkRevision;
} // forach
}
}
public HgManifest(HgRevlog hgRevlog, HgRevlogReader revlogReader, HgEncoder hgEncoder) :
base(hgRevlog, revlogReader)
{
this.hgEncoder = hgEncoder;
hgManifestReader = new HgManifestReader(this.hgEncoder);
}
private HgNodeID Commit(HgNodeID firstParentNodeID, HgNodeID secondParentNodeID, byte[] content, HgRevlog hgRevlog)
{
var data = new byte[]{};
if(firstParentNodeID != HgNodeID.Null)
{
var hgRevlogReader = new HgRevlogReader(hgRevlog, fileSystem);
data = hgRevlogReader.ReadRevlogEntry(firstParentNodeID).Data;
} // if
var linkRevision = Changelog == null ? 0 : Changelog.Revlog.Entries.Count;
var hgNodeID = new HgRevlogWriter(hgRevlog, fileSystem).WriteRevlogEntryData((uint)linkRevision, firstParentNodeID, secondParentNodeID, content);
return hgNodeID;
}
public IEnumerable<HgManifestEntry> GetManifestEntries(HgRevset hgRevset)
{
var revlogReader = new HgRevlogReader(Manifest.Revlog, fileSystem);
var entries = revlogReader.ReadRevlogEntries(hgRevset);
var manifestEntries = new HgManifestReader(Encoder).ReadManifestEntries(entries);
return manifestEntries.ToList();
}
public IEnumerable<HgChangeset> GetChangesets()
{
var revlogReader = new HgRevlogReader(Changelog.Revlog, fileSystem);
var entries = revlogReader.ReadRevlogEntries(0, UInt32.MaxValue);
var changesets = new HgChangelogReader(Encoder).ReadChangesets(entries);
return changesets.ToList();
}
public HgLargefilesEnabledFilelog(HgRevlog revlog, HgPath path, HgRevlogReader revlogReader) :
base(revlog, path, revlogReader)
{
}
public HgFilelog(HgRevlog revlog, HgPath path, HgRevlogReader revlogReader) :
base(revlog, revlogReader)
{
Path = path;
}
public HgChangelog(HgRevlog revlog, HgRevlogReader revlogReader, HgEncoder hgEncoder) :
base(revlog, revlogReader)
{
this.hgEncoder = hgEncoder;
hgChangelogReader = new HgChangelogReader(this.hgEncoder);
}
private IEnumerable<HgChunk> BuildBundleGroup(HgRepository hgRepository, HgRevlog hgRevlog, HgRevset hgRevset, Action<HgRevlogEntryData> callback = null)
{
var hgRevlogReader = new HgRevlogReader(hgRevlog, fileSystem);
//
// See http://stackoverflow.com/a/10359273/60188. Pure magic
var revisionChunks =
hgRevset.
Select(hre => hre.Revision).
OrderBy(r => r).
Select((r, i) => new { r, i }).
GroupBy(x => x.r - x.i).
Select(x => x.Select(xx => xx.r)).
Select(c => c.ToArray()).
ToArray();
if(revisionChunks.Length == 0) yield break;
byte[] prev = null;
uint prevRev = uint.MaxValue;
var prediff = false;
var hgRevlogEntry = hgRevlog[revisionChunks[0][0]];
if(hgRevlogEntry.FirstParentRevisionNodeID != HgNodeID.Null)
{
prev = hgRevlogReader.ReadRevlogEntry(hgRevlogEntry.FirstParentRevision).Data;
prediff = true;
}
foreach(var revisionChunk in revisionChunks)
{
foreach(var revision in revisionChunk)
{
hgRevlogEntry = hgRevlog[revision];
var hgChangeset = hgRepository.Changelog.Revlog[hgRevlogEntry.LinkRevision];
byte[] data = null;
if(prev == null || hgRevlogEntry.BaseRevision == hgRevlogEntry.Revision || prediff || (prevRev != UInt32.MaxValue && prevRev + 1 != revision))
{
var hgRevlogEntryData = hgRevlogReader.ReadRevlogEntry(revision);
if(prev == null)
{
//
// Trivial case
var buffer = new byte[hgRevlogEntryData.Data.Length + 12];
using(var stream = new MemoryStream(buffer))
using(var binaryWriter = new BigEndianBinaryWriter(stream))
{
binaryWriter.Write((uint)0);
binaryWriter.Write((uint)0);
binaryWriter.Write((uint)hgRevlogEntryData.Data.Length);
binaryWriter.Write(hgRevlogEntryData.Data);
} // using
data = buffer;
} // if
else
{
data = BDiff.Diff(prev, hgRevlogEntryData.Data);
if(prediff)
prediff = false;
} // else
prev = hgRevlogEntryData.Data;
} // if
else
{
data = hgRevlogReader.ReadRevlogEntryDataRaw(revision);
prev = MPatch.Patch(prev, new List<byte[]> { data });
} // else
if(callback != null) callback(new HgRevlogEntryData(hgRevlogEntry, prev));
if(performIntegrityChecks)
{
var expectedNodeID = GetRevlogEntryDataNodeID(hgRevlogEntry.FirstParentRevisionNodeID, hgRevlogEntry.SecondParentRevisionNodeID, prev);
if(expectedNodeID != hgRevlogEntry.NodeID)
{
// TODO: Exception class
throw new ApplicationException("integrity violation for " + hgRevlogEntry.NodeID.Short);
} // if
} // if
var hgChunk = new HgChunk(hgRevlogEntry.NodeID, hgRevlogEntry.FirstParentRevisionNodeID, hgRevlogEntry.SecondParentRevisionNodeID,
hgChangeset.NodeID, data);
yield return hgChunk;
prevRev = revision;
} // foreach
} // foreach
}
