unpackGitPack

fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!UnpackResult

File

Code

fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!UnpackResult {
    const io = f.job_queue.io;
    const arena = f.arena.allocator();
    // TODO don't try to get a gpa from an arena. expose this dependency higher up
    // because the backing of arena could be page allocator
    const gpa = f.arena.child_allocator;
    const object_format: git.Oid.Format = resource.want_oid;

    var res: UnpackResult = .{};
    // The .git directory is used to store the packfile and associated index, but
    // we do not attempt to replicate the exact structure of a real .git
    // directory, since that isn't relevant for fetching a package.
    {
        var pack_dir = try out_dir.createDirPathOpen(io, ".git", .{});
        defer pack_dir.close(io);
        var pack_file = try pack_dir.createFile(io, "pkg.pack", .{ .read = true });
        defer pack_file.close(io);
        var pack_file_buffer: [4096]u8 = undefined;
        var pack_file_reader = b: {
            var pack_file_writer = pack_file.writer(io, &pack_file_buffer);
            const fetch_reader = &resource.fetch_stream.reader;
            _ = try fetch_reader.streamRemaining(&pack_file_writer.interface);
            try pack_file_writer.interface.flush();
            break :b pack_file_writer.moveToReader();
        };

        var index_file = try pack_dir.createFile(io, "pkg.idx", .{ .read = true });
        defer index_file.close(io);
        var index_file_buffer: [2000]u8 = undefined;
        var index_file_writer = index_file.writer(io, &index_file_buffer);
        {
            const index_prog_node = f.prog_node.start("Index pack", 0);
            defer index_prog_node.end();
            try git.indexPack(gpa, object_format, &pack_file_reader, &index_file_writer);
        }

        {
            var index_file_reader = index_file.reader(io, &index_file_buffer);
            const checkout_prog_node = f.prog_node.start("Checkout", 0);
            defer checkout_prog_node.end();
            var repository: git.Repository = undefined;
            try repository.init(gpa, object_format, &pack_file_reader, &index_file_reader);
            defer repository.deinit();
            var diagnostics: git.Diagnostics = .{ .allocator = arena };
            try repository.checkout(io, out_dir, resource.want_oid, &diagnostics);

            if (diagnostics.errors.items.len > 0) {
                try res.allocErrors(arena, diagnostics.errors.items.len, "unable to unpack packfile");
                for (diagnostics.errors.items) |item| {
                    switch (item) {
                        .unable_to_create_file => |i| res.unableToCreateFile(i.file_name, i.code),
                        .unable_to_create_sym_link => |i| res.unableToCreateSymLink(i.file_name, i.link_name, i.code),
                    }
                }
            }
        }
    }

    try out_dir.deleteTree(io, ".git");
    return res;
}