[thirdparty/git.git] / shallow.c

#include "cache.h"
#include "commit.h"
#include "tag.h"
#include "pkt-line.h"
#include "remote.h"
#include "refs.h"
#include "sha1-array.h"
#include "diff.h"
#include "revision.h"
#include "commit-slab.h"

static int is_shallow = -1;
static struct stat shallow_stat;
static char *alternate_shallow_file;

void set_alternate_shallow_file(const char *path)
{
	if (is_shallow != -1)
		die("BUG: is_repository_shallow must not be called before set_alternate_shallow_file");
	free(alternate_shallow_file);
	alternate_shallow_file = path ? xstrdup(path) : NULL;
}

int register_shallow(const unsigned char *sha1)
{
	struct commit_graft *graft =
		xmalloc(sizeof(struct commit_graft));
	struct commit *commit = lookup_commit(sha1);

	hashcpy(graft->sha1, sha1);
	graft->nr_parent = -1;
	if (commit && commit->object.parsed)
		commit->parents = NULL;
	return register_commit_graft(graft, 0);
}

int is_repository_shallow(void)
{
	FILE *fp;
	char buf[1024];
	const char *path = alternate_shallow_file;

	if (is_shallow >= 0)
		return is_shallow;

	if (!path)
		path = git_path("shallow");
	/*
	 * fetch-pack sets '--shallow-file ""' as an indicator that no
	 * shallow file should be used. We could just open it and it
	 * will likely fail. But let's do an explicit check instead.
	 */
	if (!*path ||
	    stat(path, &shallow_stat) ||
	    (fp = fopen(path, "r")) == NULL) {
		is_shallow = 0;
		return is_shallow;
	}
	is_shallow = 1;

	while (fgets(buf, sizeof(buf), fp)) {
		unsigned char sha1[20];
		if (get_sha1_hex(buf, sha1))
			die("bad shallow line: %s", buf);
		register_shallow(sha1);
	}
	fclose(fp);
	return is_shallow;
}

struct commit_list *get_shallow_commits(struct object_array *heads, int depth,
		int shallow_flag, int not_shallow_flag)
{
	int i = 0, cur_depth = 0;
	struct commit_list *result = NULL;
	struct object_array stack = OBJECT_ARRAY_INIT;
	struct commit *commit = NULL;

	while (commit || i < heads->nr || stack.nr) {
		struct commit_list *p;
		if (!commit) {
			if (i < heads->nr) {
				commit = (struct commit *)
					deref_tag(heads->objects[i++].item, NULL, 0);
				if (!commit || commit->object.type != OBJ_COMMIT) {
					commit = NULL;
					continue;
				}
				if (!commit->util)
					commit->util = xmalloc(sizeof(int));
				*(int *)commit->util = 0;
				cur_depth = 0;
			} else {
				commit = (struct commit *)
					stack.objects[--stack.nr].item;
				cur_depth = *(int *)commit->util;
			}
		}
		if (parse_commit(commit))
			die("invalid commit");
		cur_depth++;
		if (cur_depth >= depth) {
			commit_list_insert(commit, &result);
			commit->object.flags |= shallow_flag;
			commit = NULL;
			continue;
		}
		commit->object.flags |= not_shallow_flag;
		for (p = commit->parents, commit = NULL; p; p = p->next) {
			if (!p->item->util) {
				int *pointer = xmalloc(sizeof(int));
				p->item->util = pointer;
				*pointer =  cur_depth;
			} else {
				int *pointer = p->item->util;
				if (cur_depth >= *pointer)
					continue;
				*pointer = cur_depth;
			}
			if (p->next)
				add_object_array(&p->item->object,
						NULL, &stack);
			else {
				commit = p->item;
				cur_depth = *(int *)commit->util;
			}
		}
	}

	return result;
}

void check_shallow_file_for_update(void)
{
	struct stat st;

	if (!is_shallow)
		return;
	else if (is_shallow == -1)
		die("BUG: shallow must be initialized by now");

	if (stat(git_path("shallow"), &st))
		die("shallow file was removed during fetch");
	else if (st.st_mtime != shallow_stat.st_mtime
#ifdef USE_NSEC
		 || ST_MTIME_NSEC(st) != ST_MTIME_NSEC(shallow_stat)
#endif
		   )
		die("shallow file was changed during fetch");
}

struct write_shallow_data {
	struct strbuf *out;
	int use_pack_protocol;
	int count;
};

static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
{
	struct write_shallow_data *data = cb_data;
	const char *hex = sha1_to_hex(graft->sha1);
	if (graft->nr_parent != -1)
		return 0;
	data->count++;
	if (data->use_pack_protocol)
		packet_buf_write(data->out, "shallow %s", hex);
	else {
		strbuf_addstr(data->out, hex);
		strbuf_addch(data->out, '\n');
	}
	return 0;
}

int write_shallow_commits(struct strbuf *out, int use_pack_protocol,
			  const struct sha1_array *extra)
{
	struct write_shallow_data data;
	int i;
	data.out = out;
	data.use_pack_protocol = use_pack_protocol;
	data.count = 0;
	for_each_commit_graft(write_one_shallow, &data);
	if (!extra)
		return data.count;
	for (i = 0; i < extra->nr; i++) {
		strbuf_addstr(out, sha1_to_hex(extra->sha1[i]));
		strbuf_addch(out, '\n');
		data.count++;
	}
	return data.count;
}

char *setup_temporary_shallow(const struct sha1_array *extra)
{
	struct strbuf sb = STRBUF_INIT;
	int fd;

	if (write_shallow_commits(&sb, 0, extra)) {
		struct strbuf path = STRBUF_INIT;
		strbuf_addstr(&path, git_path("shallow_XXXXXX"));
		fd = xmkstemp(path.buf);
		if (write_in_full(fd, sb.buf, sb.len) != sb.len)
			die_errno("failed to write to %s",
				  path.buf);
		close(fd);
		strbuf_release(&sb);
		return strbuf_detach(&path, NULL);
	}
	/*
	 * is_repository_shallow() sees empty string as "no shallow
	 * file".
	 */
	return xstrdup("");
}

void setup_alternate_shallow(struct lock_file *shallow_lock,
			     const char **alternate_shallow_file,
			     const struct sha1_array *extra)
{
	struct strbuf sb = STRBUF_INIT;
	int fd;

	check_shallow_file_for_update();
	fd = hold_lock_file_for_update(shallow_lock, git_path("shallow"),
				       LOCK_DIE_ON_ERROR);
	if (write_shallow_commits(&sb, 0, extra)) {
		if (write_in_full(fd, sb.buf, sb.len) != sb.len)
			die_errno("failed to write to %s",
				  shallow_lock->filename);
		*alternate_shallow_file = shallow_lock->filename;
	} else
		/*
		 * is_repository_shallow() sees empty string as "no
		 * shallow file".
		 */
		*alternate_shallow_file = "";
	strbuf_release(&sb);
}

static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
{
	int fd = *(int *)cb;
	if (graft->nr_parent == -1)
		packet_write(fd, "shallow %s\n", sha1_to_hex(graft->sha1));
	return 0;
}

void advertise_shallow_grafts(int fd)
{
	if (!is_repository_shallow())
		return;
	for_each_commit_graft(advertise_shallow_grafts_cb, &fd);
}

#define TRACE_KEY "GIT_TRACE_SHALLOW"

/*
 * Step 1, split sender shallow commits into "ours" and "theirs"
 * Step 2, clean "ours" based on .git/shallow
 */
void prepare_shallow_info(struct shallow_info *info, struct sha1_array *sa)
{
	int i;
	trace_printf_key(TRACE_KEY, "shallow: prepare_shallow_info\n");
	memset(info, 0, sizeof(*info));
	info->shallow = sa;
	if (!sa)
		return;
	info->ours = xmalloc(sizeof(*info->ours) * sa->nr);
	info->theirs = xmalloc(sizeof(*info->theirs) * sa->nr);
	for (i = 0; i < sa->nr; i++) {
		if (has_sha1_file(sa->sha1[i])) {
			struct commit_graft *graft;
			graft = lookup_commit_graft(sa->sha1[i]);
			if (graft && graft->nr_parent < 0)
				continue;
			info->ours[info->nr_ours++] = i;
		} else
			info->theirs[info->nr_theirs++] = i;
	}
}

void clear_shallow_info(struct shallow_info *info)
{
	free(info->ours);
	free(info->theirs);
}

/* Step 4, remove non-existent ones in "theirs" after getting the pack */

void remove_nonexistent_theirs_shallow(struct shallow_info *info)
{
	unsigned char (*sha1)[20] = info->shallow->sha1;
	int i, dst;
	trace_printf_key(TRACE_KEY, "shallow: remove_nonexistent_theirs_shallow\n");
	for (i = dst = 0; i < info->nr_theirs; i++) {
		if (i != dst)
			info->theirs[dst] = info->theirs[i];
		if (has_sha1_file(sha1[info->theirs[i]]))
			dst++;
	}
	info->nr_theirs = dst;
}

/* Step 5, remove non-existent ones in "ours" in the pack */
void remove_nonexistent_ours_in_pack(struct shallow_info *info,
				     struct packed_git *p)
{
	unsigned char (*sha1)[20] = info->shallow->sha1;
	int i, dst;
	trace_printf_key(TRACE_KEY, "shallow: remove_nonexistent_ours_in_pack\n");
	for (i = dst = 0; i < info->nr_ours; i++) {
		if (i != dst)
			info->ours[dst] = info->ours[i];
		if (find_pack_entry_one(sha1[info->ours[i]], p))
			dst++;
	}
	info->nr_ours = dst;
}
Commit	Line	Data
ed09aef0 JS	1	#include "cache.h"
ed09aef0 JS	2	#include "commit.h"
abef3a16	3	#include "tag.h"
3125fe52	4	#include "pkt-line.h"
58babfff NTND	5	#include "remote.h"
	6	#include "refs.h"
	7	#include "sha1-array.h"
	8	#include "diff.h"
	9	#include "revision.h"
	10	#include "commit-slab.h"
ed09aef0 JS	11
ed09aef0 JS	12	static int is_shallow = -1;
6035d6aa NTND	13	static struct stat shallow_stat;
	14	static char *alternate_shallow_file;
	15
	16	void set_alternate_shallow_file(const char *path)
	17	{
	18	if (is_shallow != -1)
	19	die("BUG: is_repository_shallow must not be called before set_alternate_shallow_file");
	20	free(alternate_shallow_file);
	21	alternate_shallow_file = path ? xstrdup(path) : NULL;
	22	}
ed09aef0 JS	23
	24	int register_shallow(const unsigned char *sha1)
	25	{
	26	struct commit_graft *graft =
	27	xmalloc(sizeof(struct commit_graft));
	28	struct commit *commit = lookup_commit(sha1);
	29
	30	hashcpy(graft->sha1, sha1);
	31	graft->nr_parent = -1;
	32	if (commit && commit->object.parsed)
	33	commit->parents = NULL;
	34	return register_commit_graft(graft, 0);
	35	}
	36
f43117a6	37	int is_repository_shallow(void)
ed09aef0 JS	38	{
	39	FILE *fp;
	40	char buf[1024];
6035d6aa	41	const char *path = alternate_shallow_file;
ed09aef0 JS	42
	43	if (is_shallow >= 0)
	44	return is_shallow;
	45
6035d6aa NTND	46	if (!path)
	47	path = git_path("shallow");
	48	/*
	49	* fetch-pack sets '--shallow-file ""' as an indicator that no
	50	* shallow file should be used. We could just open it and it
	51	* will likely fail. But let's do an explicit check instead.
	52	*/
	53	if (!*path \|\|
	54	stat(path, &shallow_stat) \|\|
	55	(fp = fopen(path, "r")) == NULL) {
ed09aef0 JS	56	is_shallow = 0;
	57	return is_shallow;
	58	}
	59	is_shallow = 1;
	60
	61	while (fgets(buf, sizeof(buf), fp)) {
	62	unsigned char sha1[20];
	63	if (get_sha1_hex(buf, sha1))
	64	die("bad shallow line: %s", buf);
	65	register_shallow(sha1);
	66	}
	67	fclose(fp);
	68	return is_shallow;
	69	}
	70
f53514bc JS	71	struct commit_list get_shallow_commits(struct object_array heads, int depth,
f53514bc JS	72	int shallow_flag, int not_shallow_flag)
ed09aef0 JS	73	{
	74	int i = 0, cur_depth = 0;
	75	struct commit_list *result = NULL;
3cd47459	76	struct object_array stack = OBJECT_ARRAY_INIT;
ed09aef0 JS	77	struct commit *commit = NULL;
	78
	79	while (commit \|\| i < heads->nr \|\| stack.nr) {
	80	struct commit_list *p;
	81	if (!commit) {
	82	if (i < heads->nr) {
	83	commit = (struct commit *)
abef3a16	84	deref_tag(heads->objects[i++].item, NULL, 0);
affeef12	85	if (!commit \|\| commit->object.type != OBJ_COMMIT) {
ed09aef0 JS	86	commit = NULL;
	87	continue;
	88	}
d64d6c9f AJ	89	if (!commit->util)
	90	commit->util = xmalloc(sizeof(int));
	91	(int )commit->util = 0;
ed09aef0 JS	92	cur_depth = 0;
	93	} else {
	94	commit = (struct commit *)
	95	stack.objects[--stack.nr].item;
	96	cur_depth = (int )commit->util;
	97	}
	98	}
dec38c81 MK	99	if (parse_commit(commit))
dec38c81 MK	100	die("invalid commit");
ed09aef0	101	cur_depth++;
682c7d2f NTND	102	if (cur_depth >= depth) {
	103	commit_list_insert(commit, &result);
	104	commit->object.flags \|= shallow_flag;
	105	commit = NULL;
	106	continue;
	107	}
	108	commit->object.flags \|= not_shallow_flag;
ed09aef0 JS	109	for (p = commit->parents, commit = NULL; p; p = p->next) {
	110	if (!p->item->util) {
	111	int *pointer = xmalloc(sizeof(int));
	112	p->item->util = pointer;
	113	*pointer = cur_depth;
	114	} else {
	115	int *pointer = p->item->util;
	116	if (cur_depth >= *pointer)
	117	continue;
	118	*pointer = cur_depth;
	119	}
4b796951 MK	120	if (p->next)
	121	add_object_array(&p->item->object,
	122	NULL, &stack);
	123	else {
	124	commit = p->item;
	125	cur_depth = (int )commit->util;
f53514bc	126	}
ed09aef0 JS	127	}
	128	}
	129
	130	return result;
	131	}
6035d6aa NTND	132
	133	void check_shallow_file_for_update(void)
	134	{
	135	struct stat st;
	136
	137	if (!is_shallow)
	138	return;
	139	else if (is_shallow == -1)
	140	die("BUG: shallow must be initialized by now");
	141
	142	if (stat(git_path("shallow"), &st))
	143	die("shallow file was removed during fetch");
	144	else if (st.st_mtime != shallow_stat.st_mtime
	145	#ifdef USE_NSEC
	146	\|\| ST_MTIME_NSEC(st) != ST_MTIME_NSEC(shallow_stat)
	147	#endif
	148	)
	149	die("shallow file was changed during fetch");
	150	}
3125fe52 NTND	151
	152	struct write_shallow_data {
	153	struct strbuf *out;
	154	int use_pack_protocol;
	155	int count;
	156	};
	157
	158	static int write_one_shallow(const struct commit_graft graft, void cb_data)
	159	{
	160	struct write_shallow_data *data = cb_data;
	161	const char *hex = sha1_to_hex(graft->sha1);
6a3bbb4d NTND	162	if (graft->nr_parent != -1)
6a3bbb4d NTND	163	return 0;
3125fe52 NTND	164	data->count++;
	165	if (data->use_pack_protocol)
	166	packet_buf_write(data->out, "shallow %s", hex);
	167	else {
	168	strbuf_addstr(data->out, hex);
	169	strbuf_addch(data->out, '\n');
	170	}
	171	return 0;
	172	}
	173
1a30f5a2 NTND	174	int write_shallow_commits(struct strbuf *out, int use_pack_protocol,
1a30f5a2 NTND	175	const struct sha1_array *extra)
3125fe52 NTND	176	{
3125fe52 NTND	177	struct write_shallow_data data;
1a30f5a2	178	int i;
3125fe52 NTND	179	data.out = out;
	180	data.use_pack_protocol = use_pack_protocol;
	181	data.count = 0;
	182	for_each_commit_graft(write_one_shallow, &data);
1a30f5a2 NTND	183	if (!extra)
	184	return data.count;
	185	for (i = 0; i < extra->nr; i++) {
	186	strbuf_addstr(out, sha1_to_hex(extra->sha1[i]));
	187	strbuf_addch(out, '\n');
	188	data.count++;
	189	}
3125fe52 NTND	190	return data.count;
	191	}
	192
1a30f5a2	193	char setup_temporary_shallow(const struct sha1_array extra)
08ea65ad NTND	194	{
	195	struct strbuf sb = STRBUF_INIT;
	196	int fd;
	197
1a30f5a2	198	if (write_shallow_commits(&sb, 0, extra)) {
08ea65ad NTND	199	struct strbuf path = STRBUF_INIT;
	200	strbuf_addstr(&path, git_path("shallow_XXXXXX"));
	201	fd = xmkstemp(path.buf);
	202	if (write_in_full(fd, sb.buf, sb.len) != sb.len)
	203	die_errno("failed to write to %s",
	204	path.buf);
	205	close(fd);
	206	strbuf_release(&sb);
	207	return strbuf_detach(&path, NULL);
	208	}
	209	/*
	210	* is_repository_shallow() sees empty string as "no shallow
	211	* file".
	212	*/
	213	return xstrdup("");
	214	}
	215
3125fe52	216	void setup_alternate_shallow(struct lock_file *shallow_lock,
1a30f5a2 NTND	217	const char **alternate_shallow_file,
1a30f5a2 NTND	218	const struct sha1_array *extra)
3125fe52 NTND	219	{
	220	struct strbuf sb = STRBUF_INIT;
	221	int fd;
	222
	223	check_shallow_file_for_update();
	224	fd = hold_lock_file_for_update(shallow_lock, git_path("shallow"),
	225	LOCK_DIE_ON_ERROR);
1a30f5a2	226	if (write_shallow_commits(&sb, 0, extra)) {
3125fe52 NTND	227	if (write_in_full(fd, sb.buf, sb.len) != sb.len)
	228	die_errno("failed to write to %s",
	229	shallow_lock->filename);
	230	*alternate_shallow_file = shallow_lock->filename;
	231	} else
	232	/*
	233	* is_repository_shallow() sees empty string as "no
	234	* shallow file".
	235	*/
	236	*alternate_shallow_file = "";
	237	strbuf_release(&sb);
	238	}
ad491366 NTND	239
	240	static int advertise_shallow_grafts_cb(const struct commit_graft graft, void cb)
	241	{
	242	int fd = (int )cb;
	243	if (graft->nr_parent == -1)
	244	packet_write(fd, "shallow %s\n", sha1_to_hex(graft->sha1));
	245	return 0;
	246	}
	247
	248	void advertise_shallow_grafts(int fd)
	249	{
	250	if (!is_repository_shallow())
	251	return;
	252	for_each_commit_graft(advertise_shallow_grafts_cb, &fd);
	253	}
58babfff NTND	254
	255	#define TRACE_KEY "GIT_TRACE_SHALLOW"
	256
	257	/*
	258	* Step 1, split sender shallow commits into "ours" and "theirs"
	259	* Step 2, clean "ours" based on .git/shallow
	260	*/
	261	void prepare_shallow_info(struct shallow_info info, struct sha1_array sa)
	262	{
	263	int i;
	264	trace_printf_key(TRACE_KEY, "shallow: prepare_shallow_info\n");
	265	memset(info, 0, sizeof(*info));
	266	info->shallow = sa;
	267	if (!sa)
	268	return;
	269	info->ours = xmalloc(sizeof(info->ours) sa->nr);
	270	info->theirs = xmalloc(sizeof(info->theirs) sa->nr);
	271	for (i = 0; i < sa->nr; i++) {
	272	if (has_sha1_file(sa->sha1[i])) {
	273	struct commit_graft *graft;
	274	graft = lookup_commit_graft(sa->sha1[i]);
	275	if (graft && graft->nr_parent < 0)
	276	continue;
	277	info->ours[info->nr_ours++] = i;
	278	} else
	279	info->theirs[info->nr_theirs++] = i;
	280	}
	281	}
	282
	283	void clear_shallow_info(struct shallow_info *info)
	284	{
	285	free(info->ours);
	286	free(info->theirs);
	287	}
	288
	289	/* Step 4, remove non-existent ones in "theirs" after getting the pack */
	290
	291	void remove_nonexistent_theirs_shallow(struct shallow_info *info)
	292	{
	293	unsigned char (*sha1)[20] = info->shallow->sha1;
	294	int i, dst;
	295	trace_printf_key(TRACE_KEY, "shallow: remove_nonexistent_theirs_shallow\n");
	296	for (i = dst = 0; i < info->nr_theirs; i++) {
	297	if (i != dst)
	298	info->theirs[dst] = info->theirs[i];
	299	if (has_sha1_file(sha1[info->theirs[i]]))
	300	dst++;
	301	}
	302	info->nr_theirs = dst;
	303	}
	304
	305	/* Step 5, remove non-existent ones in "ours" in the pack */
	306	void remove_nonexistent_ours_in_pack(struct shallow_info *info,
	307	struct packed_git *p)
	308	{
	309	unsigned char (*sha1)[20] = info->shallow->sha1;
	310	int i, dst;
	311	trace_printf_key(TRACE_KEY, "shallow: remove_nonexistent_ours_in_pack\n");
	312	for (i = dst = 0; i < info->nr_ours; i++) {
	313	if (i != dst)
	314	info->ours[dst] = info->ours[i];
	315	if (find_pack_entry_one(sha1[info->ours[i]], p))
	316	dst++;
	317	}
318	info->nr_ours = dst;
319	}