Adding Pack method to ObjectDatabase to supporting writing the packfile.

Reducing the access of packbuilder to internal.

Author: AMSadek

LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj

@@ -64,6 +64,7 @@
     <Compile Include="FileHistoryFixture.cs" />
     <Compile Include="FilterFixture.cs" />
     <Compile Include="GlobalSettingsFixture.cs" />
+    <Compile Include="PackBuilderFixture.cs" />
     <Compile Include="PatchStatsFixture.cs" />
     <Compile Include="RebaseFixture.cs" />
     <Compile Include="RefSpecFixture.cs" />

LibGit2Sharp.Tests/PackBuilderFixture.cs

@@ -0,0 +1,111 @@
+using LibGit2Sharp.Tests.TestHelpers;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace LibGit2Sharp.Tests
+{
+    public class PackBuilderFixture : BaseFixture
+    {
+        [Fact]
+        public void ObjectsWrittenSameAsOriginal()
+        {
+            // read a repo
+            // pack with default action
+            // write the pack file in a mirror repo
+            // read new repo
+            // compare
+
+            //string orgRepoPath = @"D:\TestRepos\packbuilder_testrepo_wd\packbuilder_testrepo_git_org\dot_git";
+            //string mrrRepoPath = @"D:\TestRepos\packbuilder_testrepo_wd\packbuilder_testrepo_git_mrr_1\dot_git";
+            //string packFilePath = @"D:\TestRepos\packbuilder_testrepo_wd\packbuilder_testrepo_git_mrr_1\dot_git\objects\pack";
+
+            string orgRepoPath = SandboxPackBuilderTestRepo();
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory(orgRepoPath + "_mrr");
+            string mrrRepoPath = scd.DirectoryPath;
+            string mrrRepoPathPackDirPath = mrrRepoPath + "/.git/objects";
+
+            DirectoryHelper.CopyFilesRecursively(new DirectoryInfo(orgRepoPath), new DirectoryInfo(mrrRepoPath));
+            DirectoryHelper.DeleteDirectory(mrrRepoPathPackDirPath);
+            Directory.CreateDirectory(mrrRepoPathPackDirPath);
+            Directory.CreateDirectory(mrrRepoPathPackDirPath + "/pack");
+
+            PackBuilderOptions packBuilderOptions = new PackBuilderOptions();
+            packBuilderOptions.MaximumNumberOfThreads = 0;
+            packBuilderOptions.PackFilePath = mrrRepoPathPackDirPath + "/pack";
+
+            Repository orgRepo = new Repository(orgRepoPath);
+
+            PackBuilderResults results = orgRepo.ObjectDatabase.Pack(packBuilderOptions, null);
+
+            // written objects count is the same as in objects database
+            Assert.Equal(orgRepo.ObjectDatabase.Count(), results.WrittenObjectsCount);
+
+            // loading a repo from the written pack file.
+            Repository mrrRepo = new Repository(mrrRepoPath);
+
+            // make sure the objects of the original repo are the same as the ones in the mirror repo
+            // doing that by making sure the count is the same, and the set differnce is empty
+            Assert.True(mrrRepo.ObjectDatabase.Count() == orgRepo.ObjectDatabase.Count() && !mrrRepo.ObjectDatabase.Except(orgRepo.ObjectDatabase).Any());
+
+            Assert.Equal(orgRepo.Commits.Count(), mrrRepo.Commits.Count());
+            Assert.Equal(orgRepo.Branches.Count(), mrrRepo.Branches.Count());
+            Assert.Equal(orgRepo.Refs.Count(), mrrRepo.Refs.Count());
+
+            orgRepo.Dispose();
+            mrrRepo.Dispose();
+        }
+
+        [Fact]
+        public void ObjectsWrittenSameAsOriginalUsingDelegate()
+        {
+            string orgRepoPath = SandboxPackBuilderTestRepo();
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory(orgRepoPath + "_mrr");
+            string mrrRepoPath = scd.DirectoryPath;
+            string mrrRepoPathPackDirPath = mrrRepoPath + "/.git/objects";
+
+            DirectoryHelper.CopyFilesRecursively(new DirectoryInfo(orgRepoPath), new DirectoryInfo(mrrRepoPath));
+            DirectoryHelper.DeleteDirectory(mrrRepoPathPackDirPath);
+            Directory.CreateDirectory(mrrRepoPathPackDirPath);
+            Directory.CreateDirectory(mrrRepoPathPackDirPath + "/pack");
+
+            PackBuilderOptions packBuilderOptions = new PackBuilderOptions();
+            packBuilderOptions.MaximumNumberOfThreads = 0;
+            packBuilderOptions.PackFilePath = mrrRepoPathPackDirPath + "/pack";
+
+            Repository orgRepo = new Repository(orgRepoPath);
+
+            // pack using the custom build method
+            PackBuilderResults results = orgRepo.ObjectDatabase.Pack(packBuilderOptions, TestBuildDelegate);
+
+            // written objects count is the same as in objects database
+            Assert.Equal(results.WrittenObjectsCount, orgRepo.ObjectDatabase.Count());
+
+            // loading a repo from the written pack file.
+            Repository mrrRepo = new Repository(mrrRepoPath);
+
+            // make sure the objects of the original repo are the same as the ones in the mirror repo
+            // doing that by making sure the count is the same, and the set differnce is empty
+            Assert.True(mrrRepo.ObjectDatabase.Count() == orgRepo.ObjectDatabase.Count() && !mrrRepo.ObjectDatabase.Except(orgRepo.ObjectDatabase).Any());
+
+            Assert.Equal(orgRepo.Commits.Count(), mrrRepo.Commits.Count());
+            Assert.Equal(orgRepo.Branches.Count(), mrrRepo.Branches.Count());
+            Assert.Equal(orgRepo.Refs.Count(), mrrRepo.Refs.Count());
+
+            orgRepo.Dispose();
+            mrrRepo.Dispose();
+        }
+
+        internal void TestBuildDelegate (PackBuilder builder)
+        {
+            foreach(Branch branch in builder.Repository.Branches)
+            {
+                foreach (Commit commit in branch.Commits)
+                {
+                    builder.AddRecursively(commit);
+                }
+            }
+        }
+    }
+}

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/config

@@ -0,0 +1,8 @@
+[core]
+	repositoryformatversion = 0
+	filemode = false
+	bare = false
+	logallrefupdates = true
+	symlinks = false
+	ignorecase = true
+	hideDotFiles = dotGitOnly

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/index

@@ -0,0 +1,3 @@
+x
��I
+B1]��>��'��[�������o���U/�Z�n�i"���5�S�Q�hC��.��n��<I!UP�3w�WЎRfS�+U9l�Fu����\�����\�3rD��:����-��
+�:��>=?

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/objects/87/2129051d644790636b416d1ef1ec830c5f6b90

@@ -0,0 +1 @@
+872129051d644790636b416d1ef1ec830c5f6b90

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/objects/88/e38705fdbd3608cddbe904b67c731f3234c45b

@@ -0,0 +1 @@
+Hello

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/objects/cc/628ccd10742baea8241c5924df992b5c019f71

@@ -0,0 +1 @@
+World

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/objects/ce/013625030ba8dba906f756967f9e9ca394464a

@@ -41,6 +41,7 @@ static BaseFixture()
         private static string SubmoduleTargetTestRepoWorkingDirPath { get; set; }
         private static string AssumeUnchangedRepoWorkingDirPath { get; set; }
         public static string SubmoduleSmallTestRepoWorkingDirPath { get; set; }
+        public static string PackBuilderTestRepoPath { get; private set; }
 
         public static DirectoryInfo ResourcesDirectory { get; private set; }
 
@@ -74,6 +75,7 @@ private static void SetUpTestEnvironment()
             SubmoduleTargetTestRepoWorkingDirPath = Path.Combine(sourceRelativePath, "submodule_target_wd");
             AssumeUnchangedRepoWorkingDirPath = Path.Combine(sourceRelativePath, "assume_unchanged_wd");
             SubmoduleSmallTestRepoWorkingDirPath = Path.Combine(sourceRelativePath, "submodule_small_wd");
+            PackBuilderTestRepoPath = Path.Combine(sourceRelativePath, "packbuilder_testrepo_wd");
 
             CleanupTestReposOlderThan(TimeSpan.FromMinutes(15));
         }
@@ -174,6 +176,11 @@ public string SandboxSubmoduleSmallTestRepo()
             return path;
         }
 
+        protected string SandboxPackBuilderTestRepo()
+        {
+            return Sandbox(PackBuilderTestRepoPath);
+        }
+
         protected string Sandbox(string sourceDirectoryPath, params string[] additionalSourcePaths)
         {
             var scd = BuildSelfCleaningDirectory();

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/dot_git/refs/heads/master

@@ -643,5 +643,39 @@ public virtual MergeTreeResult MergeCommits(Commit ours, Commit theirs, MergeTre
                 return mergeResult;
             }
         }
+
+        public virtual PackBuilderResults Pack(PackBuilderOptions options, Action<PackBuilder> buildDelegate)
+        {
+            PackBuilderResults results = new PackBuilderResults();
+            PackBuilder builder = new PackBuilder(repo);
+
+            // set pre-build options
+            builder.SetMaximumNumberOfThreads(options.MaximumNumberOfThreads);
+
+            if (buildDelegate == null)
+            {
+                // if no build delegate is provided, just insert all objects one by one.
+                foreach (GitObject obj in this)
+                {
+                    Console.WriteLine();
+                    builder.Add(obj);
+                }
+            }
+            else
+            {
+                // call the provided action
+                buildDelegate(builder);
+            }
+
+            // writing the pack file
+            builder.Write(options.PackFilePath);
+
+            // adding the results to the PackBuilderResults object
+            results.WrittenObjectsCount = builder.WrittenObjectsCount; 
+
+            // dispose and return
+            builder.Dispose();
+            return results;
+        }
     }
 }

LibGit2Sharp.Tests/Resources/packbuilder_testrepo_wd/hello.txt

@@ -10,67 +10,57 @@ namespace LibGit2Sharp
     public sealed class PackBuilder : IDisposable
     {
         private readonly PackBuilderSafeHandle packBuilderHandle;
+        internal Repository repo;
 
         /// <summary>
         /// Constructs a packbuilder from a repository.
         /// </summary>
-        public PackBuilder(IRepository repository)
+        internal PackBuilder(Repository repository)
         {
-            Repository repo = (Repository)repository;
+            repo = repository;
             packBuilderHandle = Proxy.git_packbuilder_new(repo.Handle);
         }
 
         /// <summary>
-        /// Insert a single object to the packbuilder.
+        /// Inserts a single object to the packbuilder.
         /// For an optimal pack it's mandatory to insert objects in recency order, commits followed by trees and blobs. (quoted from libgit2 API ref)
         /// </summary>
         /// <param name="gitObject">The object to be inserted.</param>
-        public void InsertObject(GitObject gitObject)
+        public void Add(GitObject gitObject)
         {
             Proxy.git_packbuilder_insert(packBuilderHandle, gitObject.Id, null);
         }
 
         /// <summary>
-        /// Insert a <see cref="Tag"/> object to the packbuilder.
+        /// Recursively insert an object and its referenced objects. Inserts the object as well as any object it references.
         /// </summary>
-        /// <param name="tag">The tag object to be inserted.</param>
-        public void InsertTag(Tag tag)
+        /// <param name="gitObject">The object to be recursively inserted.</param>
+        public void AddRecursively(GitObject gitObject)
         {
-            Proxy.git_packbuilder_insert(packBuilderHandle, tag.Target.Id, null);
+            Proxy.git_packbuilder_insert_recur(packBuilderHandle, gitObject.Id, null);
         }
 
-        /// <summary>
-        /// Insert a commit object. This will add a commit as well as the completed referenced tree.
-        /// </summary>
-        /// <param name="commit">The commit object to be inserted.</param>
-        public void InsertCommit(Commit commit)
+        public Repository Repository
         {
-            Proxy.git_packbuilder_insert_commit(packBuilderHandle, commit.Id);
+            get { return repo; }
         }
 
-        /// <summary>
-        /// Insert a root tree object. This will add the tree as well as all referenced trees and blobs.
-        /// </summary>
-        /// <param name="tree">The tree object to be inserted.</param>
-        public void InsertTree(Tree tree)
-        {
-            Proxy.git_packbuilder_insert_tree(packBuilderHandle, tree.Id);
-        }
+        //================
 
         /// <summary>
-        /// Recursively insert an object and its referenced objects. Inserts the object as well as any object it references.
+        /// Insert a <see cref="Tag"/> object to the packbuilder.
         /// </summary>
-        /// <param name="gitObject">The object to be recursively inserted.</param>
-        public void InsertRecursively(GitObject gitObject)
+        /// <param name="tag">The tag object to be inserted.</param>
+        internal void InsertTag(Tag tag)
         {
-            Proxy.git_packbuilder_insert_recur(packBuilderHandle, gitObject.Id, null);
+            Proxy.git_packbuilder_insert(packBuilderHandle, tag.Target.Id, null);
         }
 
         /// <summary>
         /// Writes the new pack file and corresponding index file to path.
         /// </summary>
         /// <param name="path">The path that pack and index files will be written to it.</param>
-        public void Write(string path)
+        internal void Write(string path)
         {
             Proxy.git_packbuilder_write(packBuilderHandle, path);
         }
@@ -88,7 +78,7 @@ public void Dispose()
         /// </summary>
         /// <returns> Returns the number of actual threads to be used.</returns>
         /// <param name="nThread">The Number of threads to spawn. An argument of 0 enusures using all available CPUs</param>
-        public int SetMaximumNumberOfThreads(int nThread)
+        internal int SetMaximumNumberOfThreads(int nThread)
         {
             // Libgit2 set the number of threads to 1 by default, 0 ensures git_online_cpus
             return (int)Proxy.git_packbuilder_set_threads(packBuilderHandle, (uint)nThread);
@@ -97,15 +87,15 @@ public int SetMaximumNumberOfThreads(int nThread)
         /// <summary>
         /// Get the total number of objects the packbuilder will write out.
         /// </summary>
-        public long ObjectsCount
+        internal long ObjectsCount
         {
             get { return Proxy.git_packbuilder_object_count(packBuilderHandle); }
         }
 
         /// <summary>
         /// Get the number of objects the packbuilder has already written out. This is only correct after the packfile has been written.
         /// </summary>
-        public long WrittenObjectsCount
+        internal long WrittenObjectsCount
         {
             get { return Proxy.git_packbuilder_written(packBuilderHandle); }
         }
@@ -115,4 +105,15 @@ internal PackBuilderSafeHandle Handle
             get { return packBuilderHandle; }
         }
     }
+
+    public sealed class PackBuilderResults
+    {
+        public long WrittenObjectsCount { get; set; }
+    }
+
+    public sealed class PackBuilderOptions
+    {
+        public string PackFilePath { get; set; }
+        public int MaximumNumberOfThreads { get; set; }
+    }
 }