gitは差分を保存していない — コミットを自作する

コミットを自作する。ファイルのスナップショットと履歴の点、保存用の箱。

gitは差分ではなく、丸ごと保存しています。コミットを自作して、その仕組みを確かめます。

前回: bashは魔法ではない — シェルを自作して確かめる これは【番外編】です。 このサイトの本筋は roadmap.sh に沿った段階で、Gitの自作はそこに載っていません。 読まなくても順路は繋がります。飛ばして構いません。 それでも書いているのは、Gitの導入と初期設定|user.name・改行コード・既定ブランチを設定するからずっと使い続けている道具の中身を、一度も見ていないからです。 この記事のコマンドは、すべて Ubuntu の中で打ちます。

Gitの導入から、ずっと同じ3行を打ってきました。

git add .
git commit -m "..."
git push

GitHubにも上げました。PRを作ってマージもしました。なのに、git commit を押した瞬間にディスクの上で何が起きているのかは、一度も説明していません。

たぶん、こんな絵を思い浮かべているはずです。

Gitは、前回からの変更(差分)を、履歴として順番に積んでいる。

これは間違いです。 そして、この間違いを持ったままだと、git のエラーメッセージが最後まで読めません。 detached HEAD も、fatal: bad object も、「なんか怖いことが起きた」で止まります。

正しい絵は、こうです。

Gitは、ファイルの中身をまるごと圧縮して保存し、その中身のハッシュ値をファイル名にしているだけです。 コミットは、その保存物を指す、ただのテキストです。

信じられないなら、開けば分かります。 .git の中は、暗号化もされていない、ただのフォルダです。

そして、同じものを Node.js で114行書きます。 書いたものが本物かどうかは、本物の git に読ませて確かめます。

対象レベル: 中級 / 区分: 必要に応じて読む

目次

この記事でわかること

  • Gitは差分を保存していないこと。1文字変えたら、ファイルまるごとがもう1つ保存される
  • .git の中にあるオブジェクトは blob・tree・commit の3種類しかないこと(この記事の範囲では)
  • コミットの中身が、人間が読めるただのテキストだということ。git cat-file -p HEAD で全部見える
  • なぜファイル名がハッシュ値なのか。 「短くするため」ではなく、同じ内容を二重に持たないためと改ざんが検出できるため
  • ブランチの正体は41バイトのテキストファイルだということ。だからブランチ作成が一瞬で、消しても中身は消えない
  • detached HEAD が「壊れた状態」ではないこと。.git/HEAD の1行が違うだけだということ

この記事でやること

  1. 空のリポジトリを作って .git の中を ls する。 ファイル1個を git hash-object で保存し、od で生のバイトを見る
  2. 1回コミットして、増えたオブジェクトを3つ数える。 git cat-file -p HEAD でコミットの中身を読む
  3. mygit.js を書く。 init / add / commit / log の4つを、本物と同じフォーマットで作る
  4. 自作した mygit が作ったオブジェクトを、本物の git cat-file と git log に読ませる
  5. オブジェクトを1バイト書き換えて、git fsck に見つけさせる
  6. 1000行のファイルの1行だけ変えてコミットし、blobが2つ丸ごとできることを確かめる

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
オブジェクトGitが .git/objects/ に保存する1個のかたまり。中身とファイル名が決まった規則で結びついている
blobファイルの中身そのものを保存したオブジェクト。ファイル名は入っていない
treeフォルダ1つ分の一覧を保存したオブジェクト。「このファイル名は、このblob」という対応表
committreeを1つ指して、親コミットと作者とメッセージを持つオブジェクト
SHA-1ハッシュ関数の1つ。どんな入力からも40桁の16進数を作る。ハッシュの回でやったもの
zlib圧縮の方式の1つ。Gitはオブジェクトをこれで圧縮して置いている
ref(参照)コミットのハッシュ値に付けた名前。main や feature のようなブランチ名がこれ
HEADいま自分がどこに立っているかを指す1行のファイル
loose object1オブジェクト = 1ファイルで置かれている状態。この記事で扱うのは全部これ

この記事では .git を壊しません。 作業は練習用に作る新しいフォルダの中だけで行い、GitHubに上げた ~/server などの実物のリポジトリには一切触りません。 最後に、作ったフォルダを丸ごと消して終わります。

まず、本物の .git の中を開く

作る前に、観察します。 自作したものが正しいかどうかを判断する基準が、先に要るからです。

練習用のリポジトリを作る

bash
$ mkdir -p ~/git-inside
$ cd ~/git-inside
$ git init
Initialized empty Git repository in /home/user/git-inside/.git/

git init は「サーバーに繋ぐ」でも「何かを登録する」でもありません。 .git というフォルダを1つ作っただけです。ネットワークは一切使っていません。

.git の中を ls する

ここを開いたことがある人は、ほとんどいません。

bash
$ ls .git
branches  config  description  HEAD  hooks  info  objects  refs

branches が出ない環境もあります。 新しい git では作られなくなりました。無くて正常です。

8つ(branches が無い環境では7つ)しかありません。 1つずつ、この記事に関係あるものだけ見ます。

名前中身
objects/⭐ 保存されたファイルの中身が全部ここに入る。 この記事の主役
refs/⭐ ブランチとタグ。 中は空っぽのフォルダから始まる
HEAD⭐ いま自分がどのブランチにいるかを書いた1行のファイル
configこのリポジトリだけの設定。Gitの導入回で --global を付けなかったときの行き先
hooks/コミット前などに動かすスクリプトの置き場。最初は .sample が並んでいるだけ
info/ description今回は使いません

HEAD を読んでください。

bash
$ cat .git/HEAD
ref: refs/heads/main

1行です。 「私はいま refs/heads/main というブランチにいる」と書いてあるだけ。

refs と objects も見ます。

bash
$ find .git/refs .git/objects
.git/refs
.git/refs/heads
.git/refs/tags
.git/objects
.git/objects/info
.git/objects/pack

フォルダしかありません。 ファイルは1つも無い。まだ何も保存していないので当然です。

[スクリーンショット: 01_gitの中身.png] git init のあと、ls .git と cat .git/HEAD と find .git/refs .git/objects を続けて実行した画面を撮ってください。objects の中が空であることが分かるようにしてください。

ファイル1個が、どう保存されるのか

git add を使わずに、オブジェクトだけを1個作ります。

bash
$ echo "hello git" > hello.txt
$ git hash-object hello.txt
8d0e41234f24b6da002d962a26c2495ea16a425f

40桁の16進数が返りました。 これがこのファイルの名前になります。

git hash-object は、まだ何も保存していません。 「保存するとしたら、この名前になる」を計算しただけです。find .git/objects をもう一度打っても、まだ空のままです。

保存します。-w を付けます(write の w)。

bash
$ git hash-object -w hello.txt
$ find .git/objects -type f
8d0e41234f24b6da002d962a26c2495ea16a425f
.git/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f

ここを、よく見てください。

8d0e41234f24b6da002d962a26c2495ea16a425f
↓
.git/objects/ 8d / 0e41234f24b6da002d962a26c2495ea16a425f
              ↑先頭2桁がフォルダ名   ↑残り38桁がファイル名

なぜ2桁で切ってフォルダに分けるのか。 1つのフォルダにファイルが何万個も入ると、ファイルシステムが遅くなるからです。先頭2桁で分ければ、最大256個のフォルダに散ります。性能のための工夫で、意味はありません。

保存されているのは、ただの圧縮ファイル

中身を cat してみてください。

bash
$ cat .git/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f
xK??OR04`?H???WH?,? 6A?

文字化けします。 暗号ではありません。zlib で圧縮されているだけです。

展開します。

bash
$ node -e "const z=require('node:zlib'),fs=require('node:fs');process.stdout.write(z.inflateSync(fs.readFileSync(process.argv[1])))" .git/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f | od -c
0000000   b   l   o   b       1   0  \0   h   e   l   l   o       g   i
0000020   t  \n
0000022

これが、Gitのオブジェクトの正体です。

blob 10\0hello git\n
└──┘ └┘ └┘└──────────┘
  ①   ②  ③      ④
中身意味
①blob種類。blob / tree / commit のどれか
②10中身のバイト数。hello git の9文字 + 改行1文字
③\0ヌル文字。ヘッダと中身の区切り。シェルの回で出てきた「ここまで」の印と同じもの
④hello git\nファイルの中身そのもの

od -c は、バイトを1つずつ文字として表示するコマンドです。\0 や \n のような目に見えない文字も出してくれます。coreutils に入っているので、素の Ubuntu にも必ずあります。

この40桁は、本当にこの文字列のSHA-1なのか。 自分で計算して確かめます。

bash
$ printf 'blob 10\0hello git\n' | sha1sum
8d0e41234f24b6da002d962a26c2495ea16a425f  -

完全に一致しました。

ここで、ハッシュの回の知識がそのまま効きます。 ハッシュ関数は「同じ入力なら必ず同じ結果」でした。だから、同じ中身のファイルは、世界中のどのマシンで計算しても同じ40桁になります。

ただし、パスワードのときとは目的が正反対です。パスワードでは「速いこと」が弱点でしたが、Gitは速くていいのです。 秘密を守るために使っているのではなく、中身に名前を付けるために使っているからです。

中身も見られます。専用のコマンドがあります。

bash
$ git cat-file -t 8d0e41234f24b6da002d962a26c2495ea16a425f
$ git cat-file -s 8d0e41234f24b6da002d962a26c2495ea16a425f
$ git cat-file -p 8d0e41234f24b6da002d962a26c2495ea16a425f
blob
10
hello git
オプション意味
-ttype。種類を出す
-ssize。中身のバイト数を出す
-ppretty print。中身を人が読める形で出す

さっき od -c で見た blob 10 hello git が、そのまま3つに分かれて出てきただけです。

40桁は全部打たなくて構いません。 先頭7桁くらいで一意に決まれば、git cat-file -p 8d0e412 で通ります。git log --oneline の短いハッシュは、これです。

[スクリーンショット: 02_hash-object.png] git hash-object -w hello.txt から git cat-file -p までを続けて実行し、40桁の名前・フォルダの分かれ方・展開した blob 10\0hello git が1画面に入るように撮ってください。

1回コミットして、増えたものを数える

では git add と git commit を使います。

bash
$ git add hello.txt
$ git commit -m "first commit"
[main (root-commit) da01181] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 hello.txt

オブジェクトが何個になったか、数えます。

bash
$ git cat-file --batch-all-objects --batch-check
07ed5a7aebb914e3a02edf6d622b82d364037e3c tree 37
8d0e41234f24b6da002d962a26c2495ea16a425f blob 10
da01181e829a1c2f72f24294628cf891ba79166e commit 159

3個です。そして種類は blob・tree・commit の3つだけ。

  • blob は増えていません。 さっき hash-object -w で作ったものが、そのまま使われました
  • tree が1つ増えました。 フォルダ1つ分の一覧
  • commit が1つ増えました

git cat-file --batch-all-objects --batch-check は、「持っているオブジェクトを全部、名前・種類・サイズで並べろ」という意味です。この記事で何度も使います。

git cat-file -p HEAD — コミットは、ただのテキスト

ここが、この記事の前半で一番見てほしいところです。

bash
$ git cat-file -p HEAD
tree 07ed5a7aebb914e3a02edf6d622b82d364037e3c
author user <user@example.com> 1788334118 +0900
committer user <user@example.com> 1788334118 +0900

first commit

5行です。 これがコミットの全部です。

行意味
tree ...このコミット時点の、ファイル一覧を持つ tree オブジェクトの名前
author ...書いた人と、その時刻。Gitの導入回で user.name と user.email を設定した、あの値がここに入ります
committer ...コミットした人。普通は author と同じ(違うのは、他人のパッチを取り込んだときなど)
(空行)ヘッダと本文の区切り
first commit-m で書いたメッセージ

1788334118 は、1970年1月1日からの秒数です。+0900 は時差。これで日時になっています。

git commit が保存しているのは「変更」ではありません。 「この時点のファイル一覧(tree)を指す、5行のテキスト」です。差分という言葉は、1文字も出てきていません。

さっきの hello.txt を git add した時点で、blob は既にできていました。 つまり——

git add は「予約」ではありません。 その時点のファイルの中身を、本当に .git/objects/ に保存する操作です。だから git add したあとにファイルを編集しても、add した時点の中身がコミットされます。 これが「ステージング」の実体です。

tree を辿る

コミットが指している tree を開きます。

bash
$ git cat-file -p 07ed5a7
100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f	hello.txt

1行です。

列意味
100644モード。権限の回の 644(普通のファイル)。実行可能なら 100755、フォルダなら 40000
blob指している先の種類
8d0e412...中身のオブジェクト名
hello.txtファイル名

重要: ファイル名は blob の中に入っていません。 blob は中身だけを持ち、「その中身にどんな名前が付いているか」は tree が持っています。 だから、同じ中身のファイルを2つ違う名前で置いても、blob は1個で済みます。 これが後で効きます。

HEAD から tree を一発で開く書き方もあります。

bash
$ git cat-file -p "HEAD^{tree}"
100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f	hello.txt

出てきたのは3種類だけ

ここまでで見たものを、絵にします。

  .git/HEAD
      │  「ref: refs/heads/main」
      ▼
  .git/refs/heads/main
      │  「da01181e...」(41バイトのテキスト)
      ▼
  commit da01181  ← 5行のテキスト
      │  tree 07ed5a7
      ▼
  tree 07ed5a7    ← ファイル名とblobの対応表
      │  hello.txt → 8d0e412
      ▼
  blob 8d0e412    ← 「hello git\n」そのもの

上から下に、名前で指しているだけです。

種類持っているもの持っていないもの
blobファイルの中身ファイル名・日付・権限
treeファイル名・モード・指す先中身
committree・親・作者・メッセージファイルの中身も名前も

この3つ(とタグ)以外は、ありません。 「Gitの中身」と身構えていたものの正体が、これです。

[スクリーンショット: 03_cat-file-HEAD.png] git cat-file --batch-all-objects --batch-check で3個並ぶところと、git cat-file -p HEAD の5行、git cat-file -p "HEAD^{tree}" の1行が入るように撮ってください。

同じものを Node.js で書く

観察は終わりました。作ります。

作るのは4つのコマンドです。

コマンドやること
mygit init.mygit/ を作る。objects/ refs/heads/ HEAD
mygit add <ファイル>blob を書いて、staged の一覧に足す
mygit commit <メッセージ>tree と commit を書いて、refs/heads/main を更新する
mygit logHEAD から親を辿って表示する

そして、合格の基準はこれです。

本物の git が、mygit の作ったものをそのまま読めること。

自分で書いたプログラムで「読めました」と言っても証明になりません。採点は本物にさせます。

作業場所

bash
$ mkdir -p ~/mygit
$ cd ~/mygit
$ nano mygit.js

node は npmの回で入れたものをそのまま使います。 npm install はしません。 使うのは Node.js に最初から入っている fs path zlib crypto の4つだけです。外部ライブラリは0個です。

mygit.js 全文

114行です。写し間違いを避けるため、一度に全部貼ってください。

const fs = require("node:fs");
const path = require("node:path");
const zlib = require("node:zlib");
const crypto = require("node:crypto");

const GIT_DIR = ".mygit";

function writeObject(type, content) {
  const header = Buffer.from(`${type} ${content.length}\0`, "utf8");
  const store = Buffer.concat([header, content]);
  const sha = crypto.createHash("sha1").update(store).digest("hex");
  const dir = path.join(GIT_DIR, "objects", sha.slice(0, 2));
  const file = path.join(dir, sha.slice(2));
  if (!fs.existsSync(file)) {
    fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(file, zlib.deflateSync(store));
  }
  return sha;
}

function readObject(sha) {
  const file = path.join(GIT_DIR, "objects", sha.slice(0, 2), sha.slice(2));
  const raw = zlib.inflateSync(fs.readFileSync(file));
  const nul = raw.indexOf(0);
  const type = raw.subarray(0, nul).toString("utf8").split(" ")[0];
  return { type, content: raw.subarray(nul + 1) };
}

function headRefPath() {
  const head = fs.readFileSync(path.join(GIT_DIR, "HEAD"), "utf8").trim();
  return path.join(GIT_DIR, head.replace("ref: ", ""));
}

function readHeadCommit() {
  const p = headRefPath();
  return fs.existsSync(p) ? fs.readFileSync(p, "utf8").trim() : null;
}

function readStaged() {
  const p = path.join(GIT_DIR, "staged");
  const map = new Map();
  if (!fs.existsSync(p)) return map;
  for (const line of fs.readFileSync(p, "utf8").split("\n")) {
    if (line === "") continue;
    map.set(line.slice(41), line.slice(0, 40));
  }
  return map;
}

function cmdInit() {
  fs.mkdirSync(path.join(GIT_DIR, "objects"), { recursive: true });
  fs.mkdirSync(path.join(GIT_DIR, "refs", "heads"), { recursive: true });
  fs.writeFileSync(path.join(GIT_DIR, "HEAD"), "ref: refs/heads/main\n");
  console.log(`空の mygit リポジトリを作りました: ${GIT_DIR}/`);
}

function cmdAdd(files) {
  const staged = readStaged();
  for (const f of files) {
    const sha = writeObject("blob", fs.readFileSync(f));
    staged.set(f, sha);
    console.log(`blob ${sha}  ${f}`);
  }
  const lines = [...staged.keys()].sort().map((f) => `${staged.get(f)} ${f}`);
  fs.writeFileSync(path.join(GIT_DIR, "staged"), lines.join("\n") + "\n");
}

function writeTree(staged) {
  const entries = [...staged.keys()].sort().map((name) =>
    Buffer.concat([
      Buffer.from(`100644 ${name}\0`, "utf8"),
      Buffer.from(staged.get(name), "hex"),
    ])
  );
  return writeObject("tree", Buffer.concat(entries));
}

function cmdCommit(message) {
  const staged = readStaged();
  if (staged.size === 0) {
    console.error("add してから commit してください");
    process.exit(1);
  }
  const tree = writeTree(staged);
  const parent = readHeadCommit();
  const who = `mygit <mygit@example.com> ${Math.floor(Date.now() / 1000)} +0900`;
  let body = `tree ${tree}\n`;
  if (parent) body += `parent ${parent}\n`;
  body += `author ${who}\ncommitter ${who}\n\n${message}\n`;
  const sha = writeObject("commit", Buffer.from(body, "utf8"));
  fs.writeFileSync(headRefPath(), sha + "\n");
  console.log(`[main ${sha.slice(0, 7)}] ${message}`);
  console.log(`  tree ${tree}`);
}

function cmdLog() {
  let sha = readHeadCommit();
  while (sha) {
    const text = readObject(sha).content.toString("utf8");
    const message = text.split("\n\n").slice(1).join("\n\n").trim();
    console.log(`commit ${sha}`);
    console.log(`    ${message}`);
    console.log("");
    const m = text.match(/^parent ([0-9a-f]{40})$/m);
    sha = m ? m[1] : null;
  }
}

const [cmd, ...rest] = process.argv.slice(2);
if (cmd === "init") cmdInit();
else if (cmd === "add") cmdAdd(rest);
else if (cmd === "commit") cmdCommit(rest.join(" "));
else if (cmd === "log") cmdLog();
else console.log("使い方: node mygit.js <init|add|commit|log>");

心臓部 — writeObject の9行

この記事の全部が、ここに入っています。

function writeObject(type, content) {
  const header = Buffer.from(`${type} ${content.length}\0`, "utf8");
  const store = Buffer.concat([header, content]);
  const sha = crypto.createHash("sha1").update(store).digest("hex");
  const dir = path.join(GIT_DIR, "objects", sha.slice(0, 2));
  const file = path.join(dir, sha.slice(2));
  if (!fs.existsSync(file)) {
    fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(file, zlib.deflateSync(store));
  }
  return sha;
}
行意味
${type} ${content.length}\0blob 10\0 を組み立てる。 さっき od -c で見たヘッダ、そのもの
Buffer.concat([header, content])ヘッダと中身を繋ぐ。Buffer を使うのは、画像などのバイナリでも壊さないため
createHash("sha1").update(store).digest("hex")ハッシュを計算する。 圧縮する前の、ヘッダ込みのバイト列から計算します
sha.slice(0, 2) / sha.slice(2)先頭2桁でフォルダ、残り38桁でファイル名
if (!fs.existsSync(file))すでに同じ名前のファイルがあれば、何もしない。 これが「重複しない」の実装
zlib.deflateSync(store)zlib で圧縮して書く

順番を間違えると、本物に読ませたときに落ちます。

正しいやりがちな間違い
ハッシュの対象ヘッダ + 中身(圧縮前)中身だけ / 圧縮後
保存するものヘッダ + 中身を圧縮したもの中身だけを圧縮

ハッシュは圧縮前、保存は圧縮後。 ここだけです。

tree の書き方だけ、テキストではない

writeTree に、この記事で唯一の「バイナリを組み立てる」場所があります。

Buffer.concat([
  Buffer.from(`100644 ${name}\0`, "utf8"),
  Buffer.from(staged.get(name), "hex"),
])

tree の1行は、こういう並びです。

100644 hello.txt\0<20バイトの生のハッシュ>
└─モード┘└ファイル名┘└┘└─────────────────┘
                     ヌル文字
場所形
モードとファイル名テキスト
ハッシュ40桁の文字列ではなく、20バイトの生のバイト列

Buffer.from(sha, "hex") が、"8d0e41..." という40文字を、20バイトに変換しています。 8d という2文字が、1バイトの 0x8d になります。

git cat-file -p は40桁で表示しますが、それは表示のときに16進数に直しているだけです。保存されているのは20バイトです。ここを40文字のまま書くと、tree のサイズがずれて、本物の git が読めません。

並び順も決まっています。 エントリはファイル名の順に並べる必要があります。[...staged.keys()].sort() がそれです。順番が違うと、同じ内容なのに違うハッシュになります。

残りの部分

関数やっていること
readObject読んで、inflateSync で展開し、最初の \0 の位置で切ってヘッダと中身に分ける
headRefPath.mygit/HEAD を読み、ref: を外して .mygit/refs/heads/main を組み立てる
readHeadCommitそのファイルがあれば中身(40桁)を返す。無ければ null = まだ1つもコミットしていない
readStaged.mygit/staged を1行ずつ読む。先頭40桁がハッシュ、42文字目からがファイル名
cmdInitフォルダ2つとファイル1つを作るだけ
cmdAddファイルごとに blob を書いて、一覧を書き直す
cmdCommittree を書く → 親を読む → commit のテキストを組み立てて書く → refs/heads/main を上書き
cmdLogHEAD から始めて、本文の parent 行を正規表現で拾って辿る

.mygit/staged は、本物の .git/index に当たるものです。ただし中身は自作の平文で、本物とは互換がありません。だから index という名前を避けています(理由は「つまずいたところ」に書きました)。

動かす

bash
$ node mygit.js init
$ find .mygit | sort
空の mygit リポジトリを作りました: .mygit/
.mygit
.mygit/HEAD
.mygit/objects
.mygit/refs
.mygit/refs/heads

本物の git init と、ほぼ同じ形です。

bash
$ printf 'hello git\n' > hello.txt
$ node mygit.js add hello.txt
blob 8d0e41234f24b6da002d962a26c2495ea16a425f  hello.txt

ここで一度、手を止めてください。 8d0e41234f24b6da002d962a26c2495ea16a425f。 記事の前半で、本物の git hash-object が返した40桁と、1文字も違いません。

打ち合わせも通信もしていません。「ヘッダを付けて SHA-1 を取る」という規則が同じなら、必ず同じ値になるというだけです。

bash
$ node mygit.js commit "first commit"
[main 5a03f3f] first commit
  tree 07ed5a7aebb914e3a02edf6d622b82d364037e3c

tree も一致しています。 本物が作った tree は 07ed5a7aebb914e3a02edf6d622b82d364037e3c でした。同じです。

commit だけは一致しません。 作者名と時刻が違うからです。中身が違えば名前が違う。 それで正しい動きです。

の証明 — 本物の git に読ませる

自作したものを、本物の git に採点させます。

git には「.git の代わりに、このフォルダを使え」というオプションがあります。

bash
$ git --git-dir=.mygit cat-file -t 8d0e41234f24b6da002d962a26c2495ea16a425f
$ git --git-dir=.mygit cat-file -p 8d0e41234f24b6da002d962a26c2495ea16a425f
blob
hello git

本物の git が、自作プログラムの書いたファイルを読みました。

コミットも読ませます。

bash
$ git --git-dir=.mygit cat-file -p HEAD
tree 07ed5a7aebb914e3a02edf6d622b82d364037e3c
author mygit <mygit@example.com> 1788334125 +0900
committer mygit <mygit@example.com> 1788334125 +0900

first commit

HEAD も読めています。 .mygit/HEAD → .mygit/refs/heads/main → commit と、本物が自力で辿りました。

tree も辿れます。

bash
$ git --git-dir=.mygit cat-file -p "HEAD^{tree}"
100644 blob 8d0e41234f24b6da002d962a26c2495ea16a425f	hello.txt

最後に、git log です。

bash
$ git --git-dir=.mygit log --oneline
5a03f3f first commit

git log が動きました。 Gitの114行の自作版が作ったリポジトリを、本物の git が「普通のリポジトリ」として扱っています。

これで、git commit の中身が「特別な何か」ではないことが証明できました。 決まったフォーマットでファイルを置いただけです。

壊れていないことも、本物に確認させます。

bash
$ git --git-dir=.mygit fsck

何も出ません。 fsck(ファイルシステムチェック)は、問題があるときだけ喋ります。 沈黙が合格です。

[スクリーンショット: 04_本物のgitが読む.png] node mygit.js commit の直後に、git --git-dir=.mygit cat-file -p HEAD と git --git-dir=.mygit log --oneline を実行した画面を撮ってください。自作したものを本物が読んでいることが分かる並びにしてください。

2回目のコミットと log

履歴を伸ばします。

bash
$ printf 'hello git\nsecond line\n' > hello.txt
$ printf 'memo\n' > memo.txt
$ node mygit.js add hello.txt memo.txt
$ node mygit.js commit "add memo"
blob ea111b3aa2d38b661cff3f6ec0ac37ac093041cb  hello.txt
blob a5f34b60e4fe62a2844ceea1391a0abc22525494  memo.txt
[main 22eeeb6] add memo
  tree 0795bf3f15431f52b9d1ea11a295457280dc1292
bash
$ node mygit.js log
commit 22eeeb696986a9ff89ff921a9d9a42abc4e59ab4
    add memo

commit 5a03f3feda992fb52968a767ef6c00afedf2f021
    first commit

本物と比べます。

bash
$ git --git-dir=.mygit log --oneline
22eeeb6 add memo
5a03f3f first commit

同じ2件です。

git log は、データベースを検索していません。 HEAD が指すコミットを読んで、その parent 行を読んで、また読んで……を繰り返しているだけです。cmdLog の10行がやっていることが、そのまま本物の骨格です。

だから「履歴の途中だけを消す」ということが原理的にできません。 途中を書き換えると、そこから後ろの全コミットのハッシュが変わります。

なぜ、名前がハッシュなのか

ここまで「ファイル名はハッシュ値」と何度も書きました。理由は2つです。

理由① 同じ内容を二重に持たない

memo.txt と同じ中身のファイルを、違う名前で作ってみてください。

bash
$ printf 'memo\n' > copy.txt
$ node mygit.js add copy.txt
blob a5f34b60e4fe62a2844ceea1391a0abc22525494  copy.txt

memo.txt のときと、同じ40桁です。

オブジェクトを数えます。

bash
$ git --git-dir=.mygit cat-file --batch-all-objects --batch-check
0795bf3f15431f52b9d1ea11a295457280dc1292 tree 73
07ed5a7aebb914e3a02edf6d622b82d364037e3c tree 37
22eeeb696986a9ff89ff921a9d9a42abc4e59ab4 commit 207
5a03f3feda992fb52968a767ef6c00afedf2f021 commit 163
8d0e41234f24b6da002d962a26c2495ea16a425f blob 10
a5f34b60e4fe62a2844ceea1391a0abc22525494 blob 5
ea111b3aa2d38b661cff3f6ec0ac37ac093041cb blob 22

blob は3つのままです。 ファイルは4つあるのに。

writeObject の、この2行がやっていました。

if (!fs.existsSync(file)) {

「同じ名前のファイルが既にあるなら、書かない」。 名前が中身から決まるので、名前が同じ = 中身が同じが保証されています。比較すら要りません。

これが、Gitで「ファイルを別のフォルダに移動しただけ」のコミットが軽い理由です。 blob は1バイトも増えません。変わるのは tree の中の「名前」だけです。

同じことが、ブランチとPRの回で切ったブランチにも効いています。 ブランチを切っても、ファイルの中身は1つもコピーされません。

理由② 改ざんが検出できる

オブジェクトを1つ、書き換えてみます。

bash
$ nano tamper.js
const fs = require("node:fs");
const zlib = require("node:zlib");

const file = process.argv[2];
const body = "HELLO git\n";
const store = Buffer.from(`blob ${body.length}\0${body}`, "utf8");
fs.writeFileSync(file, zlib.deflateSync(store));
console.log("書き換えました:", file);

hello git を HELLO git にするだけです。 ヘッダも正しく付け直しているので、ファイルとしては完全に正常です。

bash
$ node tamper.js .mygit/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f
$ git --git-dir=.mygit cat-file -p 8d0e41234f24b6da002d962a26c2495ea16a425f
書き換えました: .mygit/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f
HELLO git

cat-file は、素直に書き換わった中身を返しました。 cat-file は毎回ハッシュを検算しません(重いので)。

検算させます。

bash
$ git --git-dir=.mygit fsck
error: 197d3e837056a2f1c73a413e36122ba3c2c50d7b: hash-path mismatch, found at: .mygit/objects/8d/0e41234f24b6da002d962a26c2495ea16a425f
missing blob 8d0e41234f24b6da002d962a26c2495ea16a425f

一発で見つかりました。 メッセージを読んでください。

hash-path mismatch = 「中身から計算したハッシュ(197d3e83...)と、置いてある場所の名前(8d0e4123...)が食い違っている」

中身を1文字変えれば、名前が変わってしまいます。 名前を変えずに中身だけ差し替えることができない。これが「Gitの履歴は改ざんに強い」の正体です。

ハッシュの回で「一方向」という性質を見ました。 「この名前になるように、都合のいい中身を作る」ことが計算でできないので、静かに書き換えることができません。

ただし、これは「秘密が守られる」という意味ではありません。 .git の中身は誰でも読めます。守られているのは、中身ではなく「中身が変わっていないこと」です。

書き換えた blob は、そのままにして構いません。 練習用のフォルダなので、最後に丸ごと消します。 実際のリポジトリでこれが起きた場合の直し方も、原理から出ます——壊れたのは1個のファイルだけなので、同じリポジトリの別のコピー(git clone した先や GitHub 側)から、その1個を持ってくれば直ります。 名前が中身から決まっているので、どのコピーから持ってきても同じものです。

[スクリーンショット: 05_fsckが見つける.png] node tamper.js ... のあとに git --git-dir=.mygit fsck を実行し、hash-path mismatch が出ている画面を撮ってください。

ブランチの正体は、41バイトのテキストファイル

練習用の本物のリポジトリに戻ります。

bash
$ cd ~/git-inside
$ cat .git/refs/heads/main
da01181e829a1c2f72f24294628cf891ba79166e

40桁のハッシュが1つ書いてあるだけです。 サイズを測ります。

bash
$ wc -c .git/refs/heads/main
41 .git/refs/heads/main

41バイト。 40桁 + 改行1文字。これが「ブランチ main」の全部です。

ブランチを作ります。

bash
$ git branch feature
$ ls .git/refs/heads
$ cat .git/refs/heads/feature
feature  main
da01181e829a1c2f72f24294628cf891ba79166e

git branch feature がやったのは、41バイトのファイルを1つ作ることだけです。 ファイルのコピーも、履歴の複製も、1つも起きていません。

これで、ブランチとマージの回で流していた疑問が解けます。

疑問答え
なぜブランチ作成が一瞬なのか41バイトのファイルを1個書いているだけだから。プロジェクトの大きさと無関係
なぜブランチをたくさん作っても重くならないのか同上。1本 41バイト
git branch -d でブランチを消すと、コミットも消えるのか消えません。 消えるのは41バイトのファイルだけ。コミットは .git/objects/ に残っています
git switch が速いのはなぜか.git/HEAD の1行を書き換えて、作業フォルダを tree の通りに並べ直しているだけ

「ブランチを消してしまった」は、たいてい復旧できます。 ブランチという名札を捨てただけで、指されていたコミットは .git/objects/ にそのまま残っているからです(git gc で掃除されるまで)。名札を付け直せば戻ります。 どのハッシュだったかは .git/logs/HEAD(git reflog が読んでいるファイル)に記録されています。

だから detached HEAD は怖くない

あの警告を、正面から見ます。

bash
$ git checkout $(git rev-parse HEAD)
Note: switching to 'da01181e829a1c2f72f24294628cf891ba79166e'.

You are in 'detached HEAD' state. ...

初見で一番怖い画面のひとつです。 でも、.git/HEAD を見れば何が起きたか分かります。

bash
$ cat .git/HEAD
da01181e829a1c2f72f24294628cf891ba79166e

さっきまで ref: refs/heads/main だったところが、ハッシュそのものに変わっただけです。

.git/HEAD の中身状態
ref: refs/heads/mainブランチの上にいる(普通)
da01181e...(ハッシュ直接)detached HEAD

detached(切り離された)とは、「HEADが、ブランチという名札から切り離されて、コミットを直接指している」という意味です。 壊れてはいません。 危ないのは1点だけ——この状態でコミットすると、そのコミットを指す名札が誰も無いので、git switch main で戻った瞬間に迷子になります。「名札を付けてから離れろ」(git switch -c 名前)というだけの話です。

戻します。

bash
$ git switch main
$ cat .git/HEAD
ref: refs/heads/main

1行が戻りました。それだけです。

[スクリーンショット: 06_HEADの中身.png] cat .git/refs/heads/main → wc -c → git checkout <ハッシュ> → cat .git/HEAD → git switch main → cat .git/HEAD を続けて実行し、HEADの1行が変わって戻るところを撮ってください。

Gitは差分を保存していない

この記事の題です。実測します。

bash
$ mkdir -p ~/diff-demo
$ cd ~/diff-demo
$ git init
$ seq 1 1000 > big.txt
$ wc -c big.txt
$ git add big.txt
$ git commit -m "one"
3893 big.txt

約3.9KB のファイルです。1行だけ書き換えます。

bash
$ sed -i '500s/.*/CHANGED/' big.txt
$ git add big.txt
$ git commit -m "two"

オブジェクトを数えます。

bash
$ git cat-file --batch-all-objects --batch-check
1b16aed6c6d820524cf38e8883c9f0864b5e763e tree 35
c6f061bed9f4c0f93665acf9668fc184323572bf tree 35
0f4b6a0a78c8c7a8ee69bc9a14e9e6529b2f6bac commit 126
fd674ccd9ff45fde8c000a3ea5bb383e156edd7e commit 174
1179824569dcb14413904cb2b5cb036a9551024d blob 3893
ac3ed494a6531843660e754433b303358aa4fd96 blob 3897

blob が2つあります。3893バイトと3897バイト。

1行しか変えていないのに、3.9KBのファイルが、まるごともう1つ保存されました。 差分は、どこにも保存されていません。

この事実から、いくつも答えが出ます。

よくある誤解実際
「Gitは差分を積んでいる」各コミットは「その時点の全ファイルの写真」を指している
「git diff は保存された差分を表示している」git diff は、2つの写真を読んで、その場で比較して作っている。 差分は表示のときに計算される
「マージは差分を適用すること」マージは3つの写真(両方の先端と、共通の祖先)を見て、新しい写真を1枚作ること
「コンフリクトは差分がぶつかること」同じ行が、共通の祖先から見て両側で違う内容になっているので、機械がどちらの写真を採るか決められない状態
「古いコミットを見るのは重い」軽い。 その時点の写真がそのまま置いてあるので、復元に「巻き戻し」が要らない

保存の話と、表示の話を分けてください。

何をしているか
保存(add / commit)まるごと。 blob と tree と commit を書く
表示・比較(diff / log -p / blame)その場で計算。 保存物を2つ読んで比べる
マージその場で計算して、新しい保存物を作る

「Gitは差分を保存している」と思い込んでいると、この3つが全部ずれます。

ただし、永久にまるごとではない

正直に補足します。

bash
$ git count-objects -v
count: 6
in-pack: 0
packs: 0

(size などの行も出ますが、ここでは省いています)

in-pack: 0。 いま見ているのは全部 loose object(1個1ファイル)です。

Gitは、オブジェクトが増えると git gc で「packファイル」にまとめ直します。 そのときには似たオブジェクト同士を差分形式(delta)で詰め直します。 git push で送るのも、この形です。

つまり、こういう二段構えです。

層形
考え方・モデルまるごとの写真。 ここに差分は存在しない
保管・転送の都合後から差分で圧縮することがある(pack)

後者は最適化で、Gitの意味を変えません。 packを展開すれば、必ず「まるごとの写真」に戻ります。 この記事で「差分を保存していない」と言っているのは、上の層の話です。

作らなかったもの

114行で git log まで動きました。でも、本物がやっていることのほとんどをやっていません。

明示的にやらなかったものです。

やらなかったもの本物では
ネットワークclone / push / fetch。リモートとの通信プロトコルは1行も書いていません
pack上に書いた、オブジェクトをまとめて差分圧縮する仕組み
リベース履歴を作り直す操作。コミットのハッシュが全部変わる理由は、この記事で分かるようになったはずです
競合解決(マージ)3方向マージ。共通の祖先を探すところから必要

それ以外にも、これだけ足りません。

足りないもの何が起きるか
フォルダの対応writeTree はモードを 100644 固定にしています。サブフォルダを add すると壊れます
削除の対応mygit には「staged から外す」がありません。一度 add したら消せません
status / diff作業フォルダと staged を比べる処理がありません
checkouttree を読んで、作業フォルダにファイルを書き戻す処理。読む側だけ作っていません
ブランチの切り替えrefs/heads/ に他のファイルを作る機能も、HEAD を書き換える機能もありません
本物の index.mygit/staged は自作の平文。本物の .git/index はバイナリで、更新日時やサイズも持っています(それで git status が速い)
.gitignore見ていません
SHA-256対応新しいGitはSHA-256も選べます。この記事はSHA-1固定です
署名(GPG)commit オブジェクトに署名行が入る形式

足りない機能に、全部名前が付いていることが大事です。 「Gitは複雑だ」で止めず、その複雑さが上の表のどれの話なのかを言えるようになれば、調べる言葉が決まります。

これで何が変わるか

この記事は、明日から速くコミットできるようにはなりません。変わるのは、読み方です。

git のエラーメッセージが読めるようになる

エラー今までの読み方これからの読み方
fatal: not a git repository「なんか怒られた」.git フォルダが、ここにも親にも無い
fatal: bad object <ハッシュ>「壊れた?」.git/objects/ の中に、その名前のファイルが無い
error: object file ... is empty「詰んだ」オブジェクトのファイルが0バイト。 ディスクが一杯になったときなどに起きる
hash-path mismatch見たことがない中身から計算した名前と、置き場所の名前が食い違っている
You are in 'detached HEAD' state一番怖い.git/HEAD にブランチ名でなくハッシュが入っている。 それだけ
Your branch is ahead of 'origin/main' by 2 commitsなんとなくローカルの refs/heads/main と refs/remotes/origin/main が指すコミットが違う

共通しているのは、.git の中の何を指しているかが分かることです。エラー文の中の object HEAD ref が、全部この記事で開いた実物です。

「壊した」と思ったときに、どこを見るか分かる

状況見る場所
コミットが消えた気がするgit reflog(実体は .git/logs/HEAD)。オブジェクトは消えていないことが多い
ブランチを間違えて消した同上。41バイトの名札を付け直すだけ
リポジトリが壊れた気がするgit fsck。壊れているかどうかを、機械に判定させる
いま何を指しているか分からないcat .git/HEAD と git rev-parse HEAD

障害対応の回で書いた「切り分けの順番」と同じです。 中で何が起きているか分かっている対象は、切り分けられます。 Gitがブラックボックスのままだと、「とりあえずクローンし直す」しか手が無くなります。

つまずいたところ

症状原因
本物の git cat-file が fatal: Not a valid object name を返すハッシュを圧縮後のデータから計算していた。 圧縮する前の ヘッダ + 中身 から取る
同上ヘッダを付け忘れていた。 blob <バイト数>\0 が要る
git cat-file -p HEAD が fatal: bad object HEAD.mygit/HEAD の中身が ref: refs/heads/main になっていない。末尾の改行も必要
同上.mygit/refs/heads/main を作っていない。init で refs/heads まで作る
tree が読めず error: bad tree objecttree のハッシュを40文字の文字列で書いていた。 20バイトの生バイトにする(Buffer.from(sha, "hex"))
自作の tree のハッシュが本物と一致しないエントリの並び順。ファイル名でソートする
同上モードを 0100644 や 644 と書いていた。 正しくは 100644、先頭の0は付けない
git --git-dir=.mygit status が fatal: index file corruptstaged の一覧を .mygit/index という名前で置いていた。 本物はその名前をバイナリのindexだと思って読みに来る。staged など別の名前にする(この記事がそうしている理由)
git --git-dir=.mygit fsck が garbage at end of loose objectオブジェクトのファイルに余分なバイトが付いている。書き込みが途中で終わったか、追記してしまった
日本語のファイル名や画像を add すると中身が壊れるfs.readFileSync(f, "utf8") と書いている。 エンコーディングを指定せず Buffer のまま扱う
mygit log が1件しか出ないcommit で parent 行を書いていない。または refs/heads/main を更新していない
本物の git が .mygit を見てくれない--git-dir=.mygit を付け忘れ。git は既定で .git しか見ません

もう一段見たいときは、本物の git に喋らせます。

bash
$ cd ~/git-inside
$ GIT_TRACE=1 git commit --allow-empty -m "trace"

内部で何が呼ばれているかが流れます。 「魔法が起きている」ように見えていた1コマンドが、細かい処理の連なりであることが見えます。

後片づけ

常駐したものは何もありません。作ったフォルダを消すだけです。

bash
$ cd ~
$ rm -rf ~/git-inside ~/mygit ~/diff-demo

確認します。

bash
$ ls ~

rm -rf は、フォルダ名を打ち間違えると別のものを消します。 打つ前に、必ず ls ~/git-inside などで「消してよいものか」を1回見てください。 GitHubに上げた ~/server は、この記事では一度も触っていません。

入れたものは1つもありません。 git と node は元から入っていたものです。apt で入れたものが無いので、消すものもありません。

まとめ

  • .git は、暗号化もされていないただのフォルダ。 中身は objects/ refs/ HEAD の3つを見れば足りる
  • オブジェクトは blob・tree・commit の3種類だけ(+タグ)。それ以上のものは無い
  • オブジェクトの中身は <種類> <バイト数>\0<中身> を zlib で圧縮したもの。od -c で目で見た
  • ファイル名は、圧縮前のバイト列のSHA-1(40桁)。 先頭2桁がフォルダ、残り38桁がファイル名
  • blob はファイル名を持たない。 名前を持っているのは tree のほう
  • コミットは5行のテキスト。 tree・author・committer・空行・メッセージ。差分という語はどこにも無い
  • git add は予約ではない。 その時点の中身を本当に .git/objects/ に書く
  • 114行の Node.js で、本物の git cat-file と git log と git fsck が通るリポジトリが作れる
  • 自作した blob と tree のハッシュは、本物が作ったものと1文字も違わなかった。 規則が同じなら結果が同じ、というだけ
  • 名前がハッシュなのは、①同じ内容を二重に持たないため ②改ざんが検出できるため。 名前を変えずに中身を差し替えることができない
  • fsck は hash-path mismatch で一発で見つける。 cat-file は毎回検算しない
  • ブランチは41バイトのテキストファイル。 だから作成が一瞬で、消してもコミットは残る
  • detached HEAD は壊れていない。 .git/HEAD にブランチ名でなくハッシュが入っているだけ
  • Gitは差分を保存していない。 1000行の1行を変えたら、3.9KBの blob がまるごともう1つできた
  • diff とマージは「保存」ではなく「計算」の話。 保存された写真を読んで、その場で作っている
  • packでは差分圧縮する。 ただしそれは保管の最適化で、モデルは「まるごとの写真」のまま
  • ネットワーク・pack・リベース・競合解決は作っていない。 足りないものに全部名前が付くことのほうが、動いたことより大事

参考リンク


次に読む

この記事は 【番外編】roadmap.sh の外 の 20 / 35 本目です。

記事
← 前の記事DHCPサーバーの構築手順|ADでの承認(認可)とスコープの設定
→ 次の記事GPOが適用されない原因|リンク先・OU・適用順の仕組みとgpresultでの確認

ここは番外編です。 本筋から外れているので、飛ばして構いません。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

【番外編】既にあるものを自作して仕組みを知る回。roadmap.sh の範囲外。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次