git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "default.h"
5
#include "../commit.h"
6
#include "../fetch-negotiator.h"
7
#include "../prio-queue.h"
8
#include "../refs.h"
9
#include "../repository.h"
10
#include "../tag.h"
11

12
/* Remember to update object flag allocation in object.h */
13
#define COMMON		(1U << 2)
14
#define COMMON_REF	(1U << 3)
15
#define SEEN		(1U << 4)
16
#define POPPED		(1U << 5)
17

18
static int marked;
19

20
struct negotiation_state {
21
	struct prio_queue rev_list;
22
	int non_common_revs;
23
};
24

25
static void rev_list_push(struct negotiation_state *ns,
26
			  struct commit *commit, int mark)
27
{
28
	if (!(commit->object.flags & mark)) {
29
		commit->object.flags |= mark;
30

31
		if (repo_parse_commit(the_repository, commit))
32
			return;
33

34
		prio_queue_put(&ns->rev_list, commit);
35

36
		if (!(commit->object.flags & COMMON))
37
			ns->non_common_revs++;
38
	}
39
}
40

41
static int clear_marks(const char *refname, const char *referent UNUSED, const struct object_id *oid,
42
		       int flag UNUSED,
43
		       void *cb_data UNUSED)
44
{
45
	struct object *o = deref_tag(the_repository, parse_object(the_repository, oid), refname, 0);
46

47
	if (o && o->type == OBJ_COMMIT)
48
		clear_commit_marks((struct commit *)o,
49
				   COMMON | COMMON_REF | SEEN | POPPED);
50
	return 0;
51
}
52

53
/*
54
 * This function marks a rev and its ancestors as common.
55
 * In some cases, it is desirable to mark only the ancestors (for example
56
 * when only the server does not yet know that they are common).
57
 */
58
static void mark_common(struct negotiation_state *ns, struct commit *commit,
59
		int ancestors_only, int dont_parse)
60
{
61
	struct prio_queue queue = { NULL };
62

63
	if (!commit || (commit->object.flags & COMMON))
64
		return;
65

66
	prio_queue_put(&queue, commit);
67
	if (!ancestors_only) {
68
		commit->object.flags |= COMMON;
69

70
		if ((commit->object.flags & SEEN) && !(commit->object.flags & POPPED))
71
			ns->non_common_revs--;
72
	}
73
	while ((commit = prio_queue_get(&queue))) {
74
		struct object *o = (struct object *)commit;
75

76
		if (!(o->flags & SEEN))
77
			rev_list_push(ns, commit, SEEN);
78
		else {
79
			struct commit_list *parents;
80

81
			if (!o->parsed && !dont_parse)
82
				if (repo_parse_commit(the_repository, commit))
83
					continue;
84

85
			for (parents = commit->parents;
86
					parents;
87
					parents = parents->next) {
88
				struct commit *p = parents->item;
89

90
				if (p->object.flags & COMMON)
91
					continue;
92

93
				p->object.flags |= COMMON;
94

95
				if ((p->object.flags & SEEN) && !(p->object.flags & POPPED))
96
					ns->non_common_revs--;
97

98
				prio_queue_put(&queue, parents->item);
99
			}
100
		}
101
	}
102

103
	clear_prio_queue(&queue);
104
}
105

106
/*
107
 * Get the next rev to send, ignoring the common.
108
 */
109
static const struct object_id *get_rev(struct negotiation_state *ns)
110
{
111
	struct commit *commit = NULL;
112

113
	while (commit == NULL) {
114
		unsigned int mark;
115
		struct commit_list *parents;
116

117
		if (ns->rev_list.nr == 0 || ns->non_common_revs == 0)
118
			return NULL;
119

120
		commit = prio_queue_get(&ns->rev_list);
121
		repo_parse_commit(the_repository, commit);
122
		parents = commit->parents;
123

124
		commit->object.flags |= POPPED;
125
		if (!(commit->object.flags & COMMON))
126
			ns->non_common_revs--;
127

128
		if (commit->object.flags & COMMON) {
129
			/* do not send "have", and ignore ancestors */
130
			commit = NULL;
131
			mark = COMMON | SEEN;
132
		} else if (commit->object.flags & COMMON_REF)
133
			/* send "have", and ignore ancestors */
134
			mark = COMMON | SEEN;
135
		else
136
			/* send "have", also for its ancestors */
137
			mark = SEEN;
138

139
		while (parents) {
140
			if (!(parents->item->object.flags & SEEN))
141
				rev_list_push(ns, parents->item, mark);
142
			if (mark & COMMON)
143
				mark_common(ns, parents->item, 1, 0);
144
			parents = parents->next;
145
		}
146
	}
147

148
	return &commit->object.oid;
149
}
150

151
static void known_common(struct fetch_negotiator *n, struct commit *c)
152
{
153
	if (!(c->object.flags & SEEN)) {
154
		rev_list_push(n->data, c, COMMON_REF | SEEN);
155
		mark_common(n->data, c, 1, 1);
156
	}
157
}
158

159
static void add_tip(struct fetch_negotiator *n, struct commit *c)
160
{
161
	n->known_common = NULL;
162
	rev_list_push(n->data, c, SEEN);
163
}
164

165
static const struct object_id *next(struct fetch_negotiator *n)
166
{
167
	n->known_common = NULL;
168
	n->add_tip = NULL;
169
	return get_rev(n->data);
170
}
171

172
static int ack(struct fetch_negotiator *n, struct commit *c)
173
{
174
	int known_to_be_common = !!(c->object.flags & COMMON);
175
	mark_common(n->data, c, 0, 1);
176
	return known_to_be_common;
177
}
178

179
static void release(struct fetch_negotiator *n)
180
{
181
	clear_prio_queue(&((struct negotiation_state *)n->data)->rev_list);
182
	FREE_AND_NULL(n->data);
183
}
184

185
void default_negotiator_init(struct fetch_negotiator *negotiator)
186
{
187
	struct negotiation_state *ns;
188
	negotiator->known_common = known_common;
189
	negotiator->add_tip = add_tip;
190
	negotiator->next = next;
191
	negotiator->ack = ack;
192
	negotiator->release = release;
193
	negotiator->data = CALLOC_ARRAY(ns, 1);
194
	ns->rev_list.compare = compare_commits_by_commit_date;
195

196
	if (marked)
197
		refs_for_each_ref(get_main_ref_store(the_repository),
198
				  clear_marks, NULL);
199
	marked = 1;
200
}
201