[thirdparty/git.git] / builtin / commit-graph.c

#include "builtin.h"
#include "config.h"
#include "dir.h"
#include "lockfile.h"
#include "parse-options.h"
#include "repository.h"
#include "commit-graph.h"

static char const * const builtin_commit_graph_usage[] = {
	N_("git commit-graph [--object-dir <objdir>]"),
	N_("git commit-graph read [--object-dir <objdir>]"),
	N_("git commit-graph verify [--object-dir <objdir>]"),
	N_("git commit-graph write [--object-dir <objdir>] [--append] [--reachable|--stdin-packs|--stdin-commits]"),
	NULL
};

static const char * const builtin_commit_graph_verify_usage[] = {
	N_("git commit-graph verify [--object-dir <objdir>]"),
	NULL
};

static const char * const builtin_commit_graph_read_usage[] = {
	N_("git commit-graph read [--object-dir <objdir>]"),
	NULL
};

static const char * const builtin_commit_graph_write_usage[] = {
	N_("git commit-graph write [--object-dir <objdir>] [--append] [--reachable|--stdin-packs|--stdin-commits]"),
	NULL
};

static struct opts_commit_graph {
	const char *obj_dir;
	int reachable;
	int stdin_packs;
	int stdin_commits;
	int append;
} opts;


static int graph_verify(int argc, const char **argv)
{
	struct commit_graph *graph = NULL;
	char *graph_name;
	int open_ok;
	int fd;
	struct stat st;

	static struct option builtin_commit_graph_verify_options[] = {
		OPT_STRING(0, "object-dir", &opts.obj_dir,
			   N_("dir"),
			   N_("The object directory to store the graph")),
		OPT_END(),
	};

	argc = parse_options(argc, argv, NULL,
			     builtin_commit_graph_verify_options,
			     builtin_commit_graph_verify_usage, 0);

	if (!opts.obj_dir)
		opts.obj_dir = get_object_directory();

	graph_name = get_commit_graph_filename(opts.obj_dir);
	open_ok = open_commit_graph(graph_name, &fd, &st);
	if (!open_ok && errno == ENOENT)
		return 0;
	if (!open_ok)
		die_errno(_("Could not open commit-graph '%s'"), graph_name);
	graph = load_commit_graph_one_fd_st(fd, &st);
	FREE_AND_NULL(graph_name);

	if (!graph)
		return 1;

	UNLEAK(graph);
	return verify_commit_graph(the_repository, graph);
}

static int graph_read(int argc, const char **argv)
{
	struct commit_graph *graph = NULL;
	char *graph_name;
	int open_ok;
	int fd;
	struct stat st;

	static struct option builtin_commit_graph_read_options[] = {
		OPT_STRING(0, "object-dir", &opts.obj_dir,
			N_("dir"),
			N_("The object directory to store the graph")),
		OPT_END(),
	};

	argc = parse_options(argc, argv, NULL,
			     builtin_commit_graph_read_options,
			     builtin_commit_graph_read_usage, 0);

	if (!opts.obj_dir)
		opts.obj_dir = get_object_directory();

	graph_name = get_commit_graph_filename(opts.obj_dir);

	open_ok = open_commit_graph(graph_name, &fd, &st);
	if (!open_ok)
		die_errno(_("Could not open commit-graph '%s'"), graph_name);

	graph = load_commit_graph_one_fd_st(fd, &st);
	if (!graph)
		return 1;

	FREE_AND_NULL(graph_name);

	printf("header: %08x %d %d %d %d\n",
		ntohl(*(uint32_t*)graph->data),
		*(unsigned char*)(graph->data + 4),
		*(unsigned char*)(graph->data + 5),
		*(unsigned char*)(graph->data + 6),
		*(unsigned char*)(graph->data + 7));
	printf("num_commits: %u\n", graph->num_commits);
	printf("chunks:");

	if (graph->chunk_oid_fanout)
		printf(" oid_fanout");
	if (graph->chunk_oid_lookup)
		printf(" oid_lookup");
	if (graph->chunk_commit_data)
		printf(" commit_metadata");
	if (graph->chunk_extra_edges)
		printf(" extra_edges");
	printf("\n");

	UNLEAK(graph);

	return 0;
}

extern int read_replace_refs;

static int graph_write(int argc, const char **argv)
{
	struct string_list *pack_indexes = NULL;
	struct string_list *commit_hex = NULL;
	struct string_list lines;
	int result = 0;
	unsigned int flags = COMMIT_GRAPH_PROGRESS;

	static struct option builtin_commit_graph_write_options[] = {
		OPT_STRING(0, "object-dir", &opts.obj_dir,
			N_("dir"),
			N_("The object directory to store the graph")),
		OPT_BOOL(0, "reachable", &opts.reachable,
			N_("start walk at all refs")),
		OPT_BOOL(0, "stdin-packs", &opts.stdin_packs,
			N_("scan pack-indexes listed by stdin for commits")),
		OPT_BOOL(0, "stdin-commits", &opts.stdin_commits,
			N_("start walk at commits listed by stdin")),
		OPT_BOOL(0, "append", &opts.append,
			N_("include all commits already in the commit-graph file")),
		OPT_END(),
	};

	argc = parse_options(argc, argv, NULL,
			     builtin_commit_graph_write_options,
			     builtin_commit_graph_write_usage, 0);

	if (opts.reachable + opts.stdin_packs + opts.stdin_commits > 1)
		die(_("use at most one of --reachable, --stdin-commits, or --stdin-packs"));
	if (!opts.obj_dir)
		opts.obj_dir = get_object_directory();
	if (opts.append)
		flags |= COMMIT_GRAPH_APPEND;

	read_replace_refs = 0;

	if (opts.reachable)
		return write_commit_graph_reachable(opts.obj_dir, flags);

	string_list_init(&lines, 0);
	if (opts.stdin_packs || opts.stdin_commits) {
		struct strbuf buf = STRBUF_INIT;

		while (strbuf_getline(&buf, stdin) != EOF)
			string_list_append(&lines, strbuf_detach(&buf, NULL));

		if (opts.stdin_packs)
			pack_indexes = &lines;
		if (opts.stdin_commits)
			commit_hex = &lines;

		UNLEAK(buf);
	}

	if (write_commit_graph(opts.obj_dir,
			       pack_indexes,
			       commit_hex,
			       flags))
		result = 1;

	UNLEAK(lines);
	return result;
}

int cmd_commit_graph(int argc, const char **argv, const char *prefix)
{
	static struct option builtin_commit_graph_options[] = {
		OPT_STRING(0, "object-dir", &opts.obj_dir,
			N_("dir"),
			N_("The object directory to store the graph")),
		OPT_END(),
	};

	if (argc == 2 && !strcmp(argv[1], "-h"))
		usage_with_options(builtin_commit_graph_usage,
				   builtin_commit_graph_options);

	git_config(git_default_config, NULL);
	argc = parse_options(argc, argv, prefix,
			     builtin_commit_graph_options,
			     builtin_commit_graph_usage,
			     PARSE_OPT_STOP_AT_NON_OPTION);

	if (argc > 0) {
		if (!strcmp(argv[0], "read"))
			return graph_read(argc, argv);
		if (!strcmp(argv[0], "verify"))
			return graph_verify(argc, argv);
		if (!strcmp(argv[0], "write"))
			return graph_write(argc, argv);
	}

	usage_with_options(builtin_commit_graph_usage,
			   builtin_commit_graph_options);
}
Commit	Line	Data
4ce58ee3 DS	1	#include "builtin.h"
4ce58ee3 DS	2	#include "config.h"
f237c8b6 DS	3	#include "dir.h"
f237c8b6 DS	4	#include "lockfile.h"
4ce58ee3	5	#include "parse-options.h"
283e68c7	6	#include "repository.h"
f237c8b6	7	#include "commit-graph.h"
4ce58ee3 DS	8
	9	static char const * const builtin_commit_graph_usage[] = {
	10	N_("git commit-graph [--object-dir <objdir>]"),
2a2e32bd	11	N_("git commit-graph read [--object-dir <objdir>]"),
283e68c7	12	N_("git commit-graph verify [--object-dir <objdir>]"),
59fb8770	13	N_("git commit-graph write [--object-dir <objdir>] [--append] [--reachable\|--stdin-packs\|--stdin-commits]"),
f237c8b6 DS	14	NULL
	15	};
	16
283e68c7 DS	17	static const char * const builtin_commit_graph_verify_usage[] = {
	18	N_("git commit-graph verify [--object-dir <objdir>]"),
	19	NULL
	20	};
	21
2a2e32bd DS	22	static const char * const builtin_commit_graph_read_usage[] = {
	23	N_("git commit-graph read [--object-dir <objdir>]"),
	24	NULL
	25	};
	26
f237c8b6	27	static const char * const builtin_commit_graph_write_usage[] = {
59fb8770	28	N_("git commit-graph write [--object-dir <objdir>] [--append] [--reachable\|--stdin-packs\|--stdin-commits]"),
4ce58ee3 DS	29	NULL
	30	};
	31
	32	static struct opts_commit_graph {
	33	const char *obj_dir;
59fb8770	34	int reachable;
049d51a2	35	int stdin_packs;
3d5df01b	36	int stdin_commits;
7547b95b	37	int append;
4ce58ee3 DS	38	} opts;
4ce58ee3 DS	39
283e68c7 DS	40
	41	static int graph_verify(int argc, const char **argv)
	42	{
	43	struct commit_graph *graph = NULL;
	44	char *graph_name;
61df89c8 ÆAB	45	int open_ok;
	46	int fd;
	47	struct stat st;
283e68c7 DS	48
	49	static struct option builtin_commit_graph_verify_options[] = {
	50	OPT_STRING(0, "object-dir", &opts.obj_dir,
	51	N_("dir"),
	52	N_("The object directory to store the graph")),
	53	OPT_END(),
	54	};
	55
	56	argc = parse_options(argc, argv, NULL,
	57	builtin_commit_graph_verify_options,
	58	builtin_commit_graph_verify_usage, 0);
	59
	60	if (!opts.obj_dir)
	61	opts.obj_dir = get_object_directory();
	62
	63	graph_name = get_commit_graph_filename(opts.obj_dir);
61df89c8	64	open_ok = open_commit_graph(graph_name, &fd, &st);
7b8ce9c6	65	if (!open_ok && errno == ENOENT)
61df89c8	66	return 0;
7b8ce9c6 ÆAB	67	if (!open_ok)
7b8ce9c6 ÆAB	68	die_errno(_("Could not open commit-graph '%s'"), graph_name);
67a530fa	69	graph = load_commit_graph_one_fd_st(fd, &st);
283e68c7 DS	70	FREE_AND_NULL(graph_name);
	71
	72	if (!graph)
61df89c8	73	return 1;
283e68c7	74
0bfb48e6	75	UNLEAK(graph);
283e68c7 DS	76	return verify_commit_graph(the_repository, graph);
	77	}
	78
2a2e32bd DS	79	static int graph_read(int argc, const char **argv)
	80	{
	81	struct commit_graph *graph = NULL;
	82	char *graph_name;
61df89c8 ÆAB	83	int open_ok;
	84	int fd;
	85	struct stat st;
2a2e32bd DS	86
	87	static struct option builtin_commit_graph_read_options[] = {
	88	OPT_STRING(0, "object-dir", &opts.obj_dir,
	89	N_("dir"),
	90	N_("The object directory to store the graph")),
	91	OPT_END(),
	92	};
	93
	94	argc = parse_options(argc, argv, NULL,
	95	builtin_commit_graph_read_options,
	96	builtin_commit_graph_read_usage, 0);
	97
	98	if (!opts.obj_dir)
	99	opts.obj_dir = get_object_directory();
	100
	101	graph_name = get_commit_graph_filename(opts.obj_dir);
2a2e32bd	102
61df89c8 ÆAB	103	open_ok = open_commit_graph(graph_name, &fd, &st);
	104	if (!open_ok)
	105	die_errno(_("Could not open commit-graph '%s'"), graph_name);
	106
67a530fa	107	graph = load_commit_graph_one_fd_st(fd, &st);
0bfb48e6	108	if (!graph)
61df89c8	109	return 1;
883e5c7f	110
2a2e32bd DS	111	FREE_AND_NULL(graph_name);
	112
	113	printf("header: %08x %d %d %d %d\n",
	114	ntohl((uint32_t)graph->data),
	115	(unsigned char)(graph->data + 4),
	116	(unsigned char)(graph->data + 5),
	117	(unsigned char)(graph->data + 6),
	118	(unsigned char)(graph->data + 7));
	119	printf("num_commits: %u\n", graph->num_commits);
	120	printf("chunks:");
	121
	122	if (graph->chunk_oid_fanout)
	123	printf(" oid_fanout");
	124	if (graph->chunk_oid_lookup)
	125	printf(" oid_lookup");
	126	if (graph->chunk_commit_data)
	127	printf(" commit_metadata");
5af7417b SG	128	if (graph->chunk_extra_edges)
5af7417b SG	129	printf(" extra_edges");
2a2e32bd DS	130	printf("\n");
2a2e32bd DS	131
0bfb48e6	132	UNLEAK(graph);
c3756d5b	133
2a2e32bd DS	134	return 0;
	135	}
	136
d6538246 DS	137	extern int read_replace_refs;
d6538246 DS	138
f237c8b6 DS	139	static int graph_write(int argc, const char **argv)
f237c8b6 DS	140	{
d88b14b3 DS	141	struct string_list *pack_indexes = NULL;
	142	struct string_list *commit_hex = NULL;
	143	struct string_list lines;
e103f727	144	int result = 0;
5af80394	145	unsigned int flags = COMMIT_GRAPH_PROGRESS;
049d51a2	146
f237c8b6 DS	147	static struct option builtin_commit_graph_write_options[] = {
	148	OPT_STRING(0, "object-dir", &opts.obj_dir,
	149	N_("dir"),
	150	N_("The object directory to store the graph")),
59fb8770 DS	151	OPT_BOOL(0, "reachable", &opts.reachable,
59fb8770 DS	152	N_("start walk at all refs")),
049d51a2 DS	153	OPT_BOOL(0, "stdin-packs", &opts.stdin_packs,
049d51a2 DS	154	N_("scan pack-indexes listed by stdin for commits")),
3d5df01b DS	155	OPT_BOOL(0, "stdin-commits", &opts.stdin_commits,
3d5df01b DS	156	N_("start walk at commits listed by stdin")),
7547b95b DS	157	OPT_BOOL(0, "append", &opts.append,
7547b95b DS	158	N_("include all commits already in the commit-graph file")),
f237c8b6 DS	159	OPT_END(),
	160	};
	161
	162	argc = parse_options(argc, argv, NULL,
	163	builtin_commit_graph_write_options,
	164	builtin_commit_graph_write_usage, 0);
	165
59fb8770 DS	166	if (opts.reachable + opts.stdin_packs + opts.stdin_commits > 1)
59fb8770 DS	167	die(_("use at most one of --reachable, --stdin-commits, or --stdin-packs"));
f237c8b6 DS	168	if (!opts.obj_dir)
f237c8b6 DS	169	opts.obj_dir = get_object_directory();
5af80394 DS	170	if (opts.append)
5af80394 DS	171	flags \|= COMMIT_GRAPH_APPEND;
f237c8b6	172
d6538246 DS	173	read_replace_refs = 0;
d6538246 DS	174
e103f727	175	if (opts.reachable)
5af80394	176	return write_commit_graph_reachable(opts.obj_dir, flags);
59fb8770	177
d88b14b3	178	string_list_init(&lines, 0);
3d5df01b	179	if (opts.stdin_packs \|\| opts.stdin_commits) {
049d51a2	180	struct strbuf buf = STRBUF_INIT;
d88b14b3 DS	181
	182	while (strbuf_getline(&buf, stdin) != EOF)
	183	string_list_append(&lines, strbuf_detach(&buf, NULL));
	184
	185	if (opts.stdin_packs)
	186	pack_indexes = &lines;
	187	if (opts.stdin_commits)
	188	commit_hex = &lines;
0bfb48e6 MÅ	189
0bfb48e6 MÅ	190	UNLEAK(buf);
049d51a2 DS	191	}
049d51a2 DS	192
e103f727 DS	193	if (write_commit_graph(opts.obj_dir,
	194	pack_indexes,
	195	commit_hex,
5af80394	196	flags))
e103f727	197	result = 1;
049d51a2	198
0bfb48e6	199	UNLEAK(lines);
e103f727	200	return result;
f237c8b6	201	}
4ce58ee3 DS	202
	203	int cmd_commit_graph(int argc, const char *argv, const char prefix)
	204	{
	205	static struct option builtin_commit_graph_options[] = {
	206	OPT_STRING(0, "object-dir", &opts.obj_dir,
	207	N_("dir"),
	208	N_("The object directory to store the graph")),
	209	OPT_END(),
	210	};
	211
	212	if (argc == 2 && !strcmp(argv[1], "-h"))
	213	usage_with_options(builtin_commit_graph_usage,
	214	builtin_commit_graph_options);
	215
	216	git_config(git_default_config, NULL);
	217	argc = parse_options(argc, argv, prefix,
	218	builtin_commit_graph_options,
	219	builtin_commit_graph_usage,
	220	PARSE_OPT_STOP_AT_NON_OPTION);
	221
f237c8b6	222	if (argc > 0) {
2a2e32bd DS	223	if (!strcmp(argv[0], "read"))
2a2e32bd DS	224	return graph_read(argc, argv);
283e68c7 DS	225	if (!strcmp(argv[0], "verify"))
283e68c7 DS	226	return graph_verify(argc, argv);
f237c8b6 DS	227	if (!strcmp(argv[0], "write"))
	228	return graph_write(argc, argv);
	229	}
	230
4ce58ee3 DS	231	usage_with_options(builtin_commit_graph_usage,
	232	builtin_commit_graph_options);
	233	}