private Exception CreateSignature(string filePath, string signaturePath)
{
var fileIn = new FileStream(filePath, FileMode.Open, FileAccess.Read);
var fileOut = new FileStream(signaturePath, FileMode.OpenOrCreate, FileAccess.Write);
Librsync.ComputeSignature(fileIn).CopyTo(fileOut);
fileOut.Close();
fileIn.Close();
return(new Exception());
}
public string SignFile(string Blob)
{
byte[] fileData = Convert.FromBase64CharArray(Blob.ToCharArray(), 0, Blob.Length);
Stream sig = Librsync.ComputeSignature(new MemoryStream(fileData));
var memoryStream = new MemoryStream();
sig.CopyTo(memoryStream);
byte[] sigBytes = memoryStream.ToArray();
return(System.Convert.ToBase64String(sigBytes));
}
private void CreateDelta(string filePath, string signaturePath, string deltaPath)
{
var baseSignatureFileIn = new FileStream(signaturePath, FileMode.Open, FileAccess.Read);
var fileIn = new FileStream(filePath, FileMode.Open, FileAccess.Read);
var deltaOut = new FileStream(deltaPath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
Librsync.ComputeDelta(baseSignatureFileIn, fileIn).CopyTo(deltaOut);
baseSignatureFileIn.Close();
fileIn.Close();
deltaOut.Close();
}
private void NullDeltaTest(byte[] deltas, byte[] expected)
{
var nullStream = new MemoryStream();
using (var deltaStream = new MemoryStream(deltas))
{
var result = Librsync.ApplyDelta(nullStream, deltaStream);
var resultMem = new MemoryStream();
result.CopyTo(resultMem);
Assert.IsTrue(expected.SequenceEqual(resultMem.ToArray()));
}
}
public static void ComputeSignature(string FilePath, string SignatureOutputPath)
{
using (FileStream file = new FileStream(FilePath, FileMode.Open))
{
using (var signature = Librsync.ComputeSignature(file))
{
using (var signatureFile = File.Create(SignatureOutputPath))
{
signature.Seek(0, SeekOrigin.Begin);
signature.CopyTo(signatureFile);
}
}
}
}
public static void ApplyDelta(string OriginalFilePath, string DeltaPath, string NewFileOutputPath)
{
using (var originalFile = new FileStream(OriginalFilePath, FileMode.Open))
{
using (var delta = new FileStream(DeltaPath, FileMode.Open))
{
using (var resultStream = Librsync.ApplyDelta(originalFile, delta))
{
using (var newFile = File.Create(NewFileOutputPath))
{
newFile.Seek(0, SeekOrigin.Begin);
resultStream.CopyTo(newFile);
}
}
}
}
}
public static void ComputeDelta(string NewFilePath, string SignaturePath, string DeltaOutputPath)
{
using (var file = new FileStream(NewFilePath, FileMode.Open))
{
using (var signature = new FileStream(SignaturePath, FileMode.Open))
{
using (var delta = Librsync.ComputeDelta(signature, file))
{
using (var deltaFile = File.Create(DeltaOutputPath))
{
//delta.Seek(0, SeekOrigin.Begin);
delta.CopyTo(deltaFile);
}
}
}
}
}
public void RunIteration()
{
var file = MakeRandomFile();
var newFile = file;
for (int i = 0; i < 10; i++)
{
newFile = ApplyChange(newFile);
var signature = Librsync.ComputeSignature(new MemoryStream(file));
var delta = Librsync.ComputeDelta(signature, new MemoryStream(newFile));
var deltaMem = new MemoryStream();
delta.CopyTo(deltaMem);
deltaMem.Seek(0, SeekOrigin.Begin);
var regenerated = Librsync.ApplyDelta(new MemoryStream(file), deltaMem);
var regeneratedMem = new MemoryStream();
regenerated.CopyTo(regeneratedMem);
Assert.IsTrue(newFile.SequenceEqual(regeneratedMem.ToArray()));
}
}
public void PatchSeekTest()
{
var file = MakeRandomFile();
var newFile = ApplyChange(file);
var signature = Librsync.ComputeSignature(new MemoryStream(file));
var delta = Librsync.ComputeDelta(signature, new MemoryStream(newFile));
var deltaMem = new MemoryStream();
delta.CopyTo(deltaMem);
deltaMem.Seek(0, SeekOrigin.Begin);
var regenerated = Librsync.ApplyDelta(new MemoryStream(file), deltaMem);
var regeneratedMem = new MemoryStream();
regenerated.CopyTo(regeneratedMem);
Assert.AreEqual(regeneratedMem.Length, regenerated.Length);
for (int i = 0; i < regeneratedMem.Length; i++)
{
regeneratedMem.Seek(i, SeekOrigin.Begin);
regenerated.Seek(i, SeekOrigin.Begin);
Assert.AreEqual(regeneratedMem.ReadByte(), regenerated.ReadByte());
}
}
