public async Task CanCreateType(GitIdType idType)
{
string p = TestContext.PerTestDirectory(idType.ToString());
var r = GitRepository.Init(p, new GitRepositoryInitArgs {
IdType = idType
});
Assert.IsFalse(r.Commits.Any(), "No commits");
Assert.IsFalse(r.Blobs.Any(), "No blobs");
Assert.IsFalse(r.Remotes.Any(), "No remotes");
var cw = GitCommitWriter.Create();
cw.Author = cw.Committer = new GitSignature("A A", "A@A", new DateTime(2020, 2, 2, 0, 0, 0, DateTimeKind.Utc));
var c = await cw.WriteAndFetchAsync(r);
Assert.AreEqual(idType, c.Id.Type);
using (var t = r.References.CreateUpdateTransaction())
{
t.UpdateHead(c.Id);
await t.CommitAsync();
}
Assert.AreEqual("", await r.GetPlumbing().ConsistencyCheck(new() { Full = true }));
Assert.AreEqual(idType, r.Head.Id !.Type);
Assert.AreEqual(c.Id, r.Head.Id);
}
public GitRepositoryObjectRepository(GitRepository repository, string objectsDir)
: base(repository, "Repository:" + Path.GetDirectoryName(objectsDir))
{
if (!Directory.Exists(Path.Combine(objectsDir)))
{
throw new GitRepositoryException($"{objectsDir} does not exist");
}
ObjectsDir = objectsDir;
_idType = GitIdType.Sha1;
_repositories = new(() => GetRepositories().ToArray());
}
public static async ValueTask <GitId> ReadGitIdAsync(this Bucket bucket, GitIdType type)
{
if (bucket is null)
{
throw new ArgumentNullException(nameof(bucket));
}
int hl = type.HashLength();
var bb = await bucket.ReadFullAsync(hl).ConfigureAwait(false);
if (bb.Length == hl)
{
return(new GitId(type, bb.ToArray()));
}
else
{
throw new BucketEofException(bucket);
}
}
private IEnumerable <GitObjectRepository> GetRepositories()
{
int format = Repository.Configuration.GetInt("core", "repositoryformatversion") ?? -1;
if (format == 1)
{
foreach (var(key, value) in Repository.Configuration.GetGroup("extensions", null))
{
switch (key)
{
case "noop":
break;
case "partialclone":
PromisorRemote = value;
break;
case "objectformat":
if (string.Equals(value, "sha1", StringComparison.OrdinalIgnoreCase))
{
/* Do nothing */
}
else if (string.Equals(value, "sha256", StringComparison.OrdinalIgnoreCase))
{
Repository.SetSHA256(); // Ugly experimental hack for now
_idType = GitIdType.Sha256;
}
else
{
throw new GitException($"Found unsupported objectFormat {value} in repository {Repository.FullPath}");
}
break;
case "worktreeconfig":
break;
default:
throw new GitException($"Found unsupported extension {key} in repository {Repository.FullPath}");
}
}
}
else if (format != 0)
{
throw new GitException($"Found unsupported repository format {format} for {Repository.FullPath}");
}
// Check for commit chain first, to allow cheap access to commit type
string chain = Path.Combine(ObjectsDir, "info", "commit-graph");
if (File.Exists(chain) && Repository.Configuration.Lazy.CommitGraph)
{
yield return(new GitCommitGraph(Repository, chain));
}
else if (Directory.Exists(chain += "s") && File.Exists(Path.Combine(chain, "commit-graph-chain")) && Repository.Configuration.Lazy.CommitGraph)
{
yield return(new CommitGraphChain(Repository, chain));
}
string multipackFile = Path.Combine(ObjectsDir, "pack", "multi-pack-index");
MultiPackObjectRepository?multiPack = null;
if (File.Exists(multipackFile) && Repository.Configuration.Lazy.MultiPack)
{
MultiPackObjectRepository mp = new MultiPackObjectRepository(Repository, multipackFile);
if (mp.CanLoad())
{
yield return(mp);
multiPack = mp;
}
else
{
mp.Dispose();
}
}
foreach (var pack in Directory.EnumerateFiles(Path.Combine(ObjectsDir, "pack"), "pack-*.pack"))
{
// TODO: Check if length matches hashtype?
if (!multiPack?.ContainsPack(pack) ?? true)
{
yield return(new PackObjectRepository(Repository, pack, _idType));
}
}
yield return(new FileObjectRepository(Repository, ObjectsDir));
var alternatesFile = Path.Combine(ObjectsDir, "info/alternates");
if (File.Exists(alternatesFile))
{
foreach (var line in File.ReadAllLines(alternatesFile))
{
var l = line.Trim();
if (string.IsNullOrWhiteSpace(l))
{
continue;
}
else if (l[0] == '#' || l[0] == ';')
{
continue;
}
string?dir = null;
var p = Path.Combine(ObjectsDir, l);
if (Directory.Exists(p))
{
dir = p;
}
if (dir != null)
{
yield return(new GitRepositoryObjectRepository(Repository, dir));
}
}
}
}
internal GitInternalConfigAccess(GitIdType type)
{
IdType = type;
}
public GitPackFrameBucket(Bucket inner, GitIdType idType, Func <GitId, ValueTask <GitObjectBucket?> >?fetchBucketById = null)
: base(inner.WithPosition())
{
_idType = idType;
_fetchBucketById = fetchBucketById;
}
public PackObjectRepository(GitRepository repository, string packFile, GitIdType idType)
: base(repository, "Pack:" + packFile)
{
PackFile = packFile ?? throw new ArgumentNullException(nameof(packFile));
_idType = idType;
}
/// <summary>
/// Return length of this hash in bytes
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static int HashLength(this GitIdType type)
{
return(GitId.HashLength(type));
}
