grzegorzblok / fastrsyncnet Goto Github PK

        var signatureBuilder = new SignatureBuilder();
        using (var basisStream = new FileStream(Destinationfile, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (var signatureStream = new FileStream(signaturefile, FileMode.Create, FileAccess.Write, FileShare.Read))
        {
            signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
        }


        //var delta = new DeltaBuilder();
        //signatureBuilder.ProgressReport = new ConsoleProgressReporter();
        //using (var newFileStream = new FileStream(newFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
        //using (var signatureStream = new FileStream(signatureFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
        //using (var deltaStream = new FileStream(deltaFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
        //{
        //    delta.BuildDelta(newFileStream, new SignatureReader(signatureStream, delta.ProgressReporter), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
        //}
        var delta = new DeltaBuilder();
        
        using (var newFileStream = new FileStream(sourcefile, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (var signatureStream = new FileStream(signaturefile, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (var deltaStream = new FileStream(Deltafile, FileMode.Create, FileAccess.Write, FileShare.Read))
        {
            delta.BuildDelta(newFileStream, new SignatureReader(signatureStream, delta.ProgressReport), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
        }

        var deltaapp = new DeltaApplier
        {
            SkipHashCheck = true
        };
        using (var basisStream = new FileStream(Destinationfile, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
        using (var deltaStream = new FileStream(Deltafile, FileMode.Open, FileAccess.Read, FileShare.Read))
        using (var newFileStream = new FileStream(sourcefile, FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            deltaapp.Apply(newFileStream, new BinaryDeltaReader(deltaStream, ProgressReport), basisStream);
        }

class Program
    {

        static ConsoleProgressReporter Progress = new ConsoleProgressReporter();


        static string GameLocation = Path.Combine(Path.Combine(@"C:\Users\baile\Downloads", "GameData"));

        static string TempStore = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Diffs", "Local");

        static HttpClient Client = new HttpClient() 
        {
            BaseAddress = new Uri("http://localhost:5000/api/")
        };

        static async Task Main(string[] args)
        {
            var filesToSig = Directory.EnumerateFiles(Path.Combine(@"C:\Users\baile\Downloads", "GameData"), "*", SearchOption.AllDirectories);
            List<Container> Updates = new List<Container>();

            foreach (var file in filesToSig)
            {
                var sInfo = new FileInfo(file);
                var sigInfo = await GenerateSignature(sInfo);
                Updates.Add(new Container() 
                {
                    Source = sInfo,
                    Signature = sigInfo,
                    Delta = await GetDeltaFromServer(sInfo, sigInfo)
                });
            }


            Console.Clear();
            var updateQuery = Updates.Where(x => x.Delta != null);
            Console.WriteLine($"Updating {updateQuery.Count()} files");

            foreach (var update in updateQuery)
            {
                var result = await UpdateFile(update.Delta, update.Source, update.Signature);
            }
        }

        private static async Task<bool> UpdateFile(FileInfo delta, FileInfo source, FileInfo sig)
        {
            var updatedInfo = new FileInfo(Path.Combine(TempStore, "Updates", source.FullName.Substring(GameLocation.Length + 1)));
            Directory.CreateDirectory(Path.GetDirectoryName(updatedInfo.FullName));
            await RSync.PatchFile(updatedInfo.FullName, sig.FullName, delta.FullName, false, Progress);

            updatedInfo.Refresh();

            return false;
        }

        private static async Task<FileInfo> GetDeltaFromServer(FileInfo source, FileInfo sig)
        {
            try
            {
                var deltaInfo = new FileInfo(Path.Combine(TempStore, "Deltas", Path.GetFileName(source.Name) + ".octodelta"));
                Directory.CreateDirectory(Path.GetDirectoryName(deltaInfo.FullName));
                using (var fs = sig.OpenRead())
                {
                    var content = new MultipartFormDataContent();
                    content.Add(new StreamContent(fs), "FormFile" ,fs.Name);
                    content.Add(new StringContent(source.FullName.Substring(GameLocation.Length+1)), "FileName");
                    content.Add(new StringContent(source.Sha1()), "Sha1");
                    var result = await Client.PostAsync("diff", content);

                    if (result.IsSuccessStatusCode)
                    {
                        using (var saveDelta = new FileStream(deltaInfo.FullName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
                        {
                            using (var deltaStream = await result.Content.ReadAsStreamAsync())
                            {
                                await deltaStream.CopyToAsync(saveDelta);
                            }
                        }
                    }
                    else
                    {
                        return null;
                    }

                }
                deltaInfo.Refresh();
                return deltaInfo;
            }
            catch (Exception er)
            {
                return null;
            }
        }

        private static async Task<FileInfo> GenerateSignature(FileInfo sourceFile)
        {
            var sigInfo = new FileInfo(Path.Combine(TempStore, "Signatures", Path.GetFileName(sourceFile.FullName) + ".octosig"));
            Directory.CreateDirectory(Path.GetDirectoryName(sigInfo.FullName));
            await RSync.CalculateSignature(sourceFile.FullName, sigInfo.FullName, Progress);

            sigInfo.Refresh();
            return sigInfo;
        }
    }

    class Container
    {
        public FileInfo Delta { get; set; }
        public FileInfo Source { get; set; }
        public FileInfo Signature { get; set; }
    }

public static class RSync
    {
        public static async Task CalculateSignature(string filePath, string signaturePath, IProgress<ProgressReport> Progress = null)
        {
            var signatureBuilder = new SignatureBuilder() { 
                ProgressReport = Progress
            };

            using (var basisStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (var signatureStream = new FileStream(signaturePath, FileMode.Create, FileAccess.Write, FileShare.Read))
            {
                await signatureBuilder.BuildAsync(basisStream, new SignatureWriter(signatureStream));
            }
        }

        public static async Task CalculateDelta(string updatedFilePath, string signaturePath, string deltaPath, IProgress<ProgressReport> Progress = null)
        {
            var delta = new DeltaBuilder();
            delta.ProgressReport = Progress;
            using (var newFileStream = new FileStream(updatedFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (var signatureStream = new FileStream(signaturePath, FileMode.Open, FileAccess.Read, FileShare.Read))
            using (var deltaStream = new FileStream(deltaPath, FileMode.Create, FileAccess.Write, FileShare.Read))
            {
                await delta.BuildDeltaAsync(newFileStream, new SignatureReader(signatureStream, delta.ProgressReport), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
            }
        }

        public static async Task PatchFile(string updatedFile, string basisFile, string deltaPath, bool SkipHashCheck = false, IProgress<ProgressReport> Progress = null)
        {
            try
            {
                var delta = new DeltaApplier
                {
                    SkipHashCheck = SkipHashCheck
                };

                using (var basisStream = new FileStream(basisFile, FileMode.Open, FileAccess.Read, FileShare.Read))
                using (var deltaStream = new FileStream(deltaPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                using (var newFileStream = new FileStream(updatedFile, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
                {
                    await delta.ApplyAsync(basisStream, new BinaryDeltaReader(deltaStream, Progress), newFileStream);
                }
            }
            catch (Exception er)
            {

            }
        }
    }

[Route("api/[controller]")]
    [ApiController]
    public class DiffController : ControllerBase
    {

        private string TempStore = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Diffs", "Server");
        private string GameLocation = Path.Combine(Path.Combine(@"C:\Users\baile\Downloads", "GameData_Updated"));

        [HttpPost]
        public async Task<IActionResult> GenerateDiff([FromForm] DeltaRequest request)
        {
            var result = await GenerateDiffFile(request.FormFile, request.FileName, request.Sha1);

            if (result != null)
                return new FileStreamResult(result.OpenRead(), "application/octet-stream");
            else return new BadRequestResult();
        }


        private async Task<FileInfo> GenerateDiffFile(IFormFile file, string fileName, string sha)
        {

            try
            {
                var signatureFile = new FileInfo(Path.Combine(TempStore, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".octosig"));
                var updatedFileName = new FileInfo(Path.Combine(GameLocation, fileName));

                if (updatedFileName.Sha1() == sha)
                    return null;

                Directory.CreateDirectory(Path.GetDirectoryName(signatureFile.FullName));

                using (var fs = new FileStream(signatureFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read))
                using (var reader = file.OpenReadStream())
                {
                    await reader.CopyToAsync(fs);
                }

                var deltaInfo = new FileInfo(Path.Combine(TempStore, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".octodelta"));

                Directory.CreateDirectory(Path.GetDirectoryName(deltaInfo.FullName));

                await RSync.CalculateDelta(updatedFileName.FullName, signatureFile.FullName, deltaInfo.FullName);

                deltaInfo.Refresh();
                return deltaInfo;
            }
            catch (Exception)
            {
                return null;
            }
        }
    }