git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "gettext.h"
5
#include "hex.h"
6
#include "object-store-ll.h"
7
#include "promisor-remote.h"
8
#include "config.h"
9
#include "trace2.h"
10
#include "transport.h"
11
#include "strvec.h"
12
#include "packfile.h"
13
#include "environment.h"
14

15
struct promisor_remote_config {
16
	struct promisor_remote *promisors;
17
	struct promisor_remote **promisors_tail;
18
};
19

20
static int fetch_objects(struct repository *repo,
21
			 const char *remote_name,
22
			 const struct object_id *oids,
23
			 int oid_nr)
24
{
25
	struct child_process child = CHILD_PROCESS_INIT;
26
	int i;
27
	FILE *child_in;
28
	int quiet;
29

30
	if (git_env_bool(NO_LAZY_FETCH_ENVIRONMENT, 0)) {
31
		static int warning_shown;
32
		if (!warning_shown) {
33
			warning_shown = 1;
34
			warning(_("lazy fetching disabled; some objects may not be available"));
35
		}
36
		return -1;
37
	}
38

39
	child.git_cmd = 1;
40
	child.in = -1;
41
	if (repo != the_repository)
42
		prepare_other_repo_env(&child.env, repo->gitdir);
43
	strvec_pushl(&child.args, "-c", "fetch.negotiationAlgorithm=noop",
44
		     "fetch", remote_name, "--no-tags",
45
		     "--no-write-fetch-head", "--recurse-submodules=no",
46
		     "--filter=blob:none", "--stdin", NULL);
47
	if (!git_config_get_bool("promisor.quiet", &quiet) && quiet)
48
		strvec_push(&child.args, "--quiet");
49
	if (start_command(&child))
50
		die(_("promisor-remote: unable to fork off fetch subprocess"));
51
	child_in = xfdopen(child.in, "w");
52

53
	trace2_data_intmax("promisor", repo, "fetch_count", oid_nr);
54

55
	for (i = 0; i < oid_nr; i++) {
56
		if (fputs(oid_to_hex(&oids[i]), child_in) < 0)
57
			die_errno(_("promisor-remote: could not write to fetch subprocess"));
58
		if (fputc('\n', child_in) < 0)
59
			die_errno(_("promisor-remote: could not write to fetch subprocess"));
60
	}
61

62
	if (fclose(child_in) < 0)
63
		die_errno(_("promisor-remote: could not close stdin to fetch subprocess"));
64
	return finish_command(&child) ? -1 : 0;
65
}
66

67
static struct promisor_remote *promisor_remote_new(struct promisor_remote_config *config,
68
						   const char *remote_name)
69
{
70
	struct promisor_remote *r;
71

72
	if (*remote_name == '/') {
73
		warning(_("promisor remote name cannot begin with '/': %s"),
74
			remote_name);
75
		return NULL;
76
	}
77

78
	FLEX_ALLOC_STR(r, name, remote_name);
79

80
	*config->promisors_tail = r;
81
	config->promisors_tail = &r->next;
82

83
	return r;
84
}
85

86
static struct promisor_remote *promisor_remote_lookup(struct promisor_remote_config *config,
87
						      const char *remote_name,
88
						      struct promisor_remote **previous)
89
{
90
	struct promisor_remote *r, *p;
91

92
	for (p = NULL, r = config->promisors; r; p = r, r = r->next)
93
		if (!strcmp(r->name, remote_name)) {
94
			if (previous)
95
				*previous = p;
96
			return r;
97
		}
98

99
	return NULL;
100
}
101

102
static void promisor_remote_move_to_tail(struct promisor_remote_config *config,
103
					 struct promisor_remote *r,
104
					 struct promisor_remote *previous)
105
{
106
	if (!r->next)
107
		return;
108

109
	if (previous)
110
		previous->next = r->next;
111
	else
112
		config->promisors = r->next ? r->next : r;
113
	r->next = NULL;
114
	*config->promisors_tail = r;
115
	config->promisors_tail = &r->next;
116
}
117

118
static int promisor_remote_config(const char *var, const char *value,
119
				  const struct config_context *ctx UNUSED,
120
				  void *data)
121
{
122
	struct promisor_remote_config *config = data;
123
	const char *name;
124
	size_t namelen;
125
	const char *subkey;
126

127
	if (parse_config_key(var, "remote", &name, &namelen, &subkey) < 0)
128
		return 0;
129

130
	if (!strcmp(subkey, "promisor")) {
131
		char *remote_name;
132

133
		if (!git_config_bool(var, value))
134
			return 0;
135

136
		remote_name = xmemdupz(name, namelen);
137

138
		if (!promisor_remote_lookup(config, remote_name, NULL))
139
			promisor_remote_new(config, remote_name);
140

141
		free(remote_name);
142
		return 0;
143
	}
144
	if (!strcmp(subkey, "partialclonefilter")) {
145
		struct promisor_remote *r;
146
		char *remote_name = xmemdupz(name, namelen);
147

148
		r = promisor_remote_lookup(config, remote_name, NULL);
149
		if (!r)
150
			r = promisor_remote_new(config, remote_name);
151

152
		free(remote_name);
153

154
		if (!r)
155
			return 0;
156

157
		return git_config_string(&r->partial_clone_filter, var, value);
158
	}
159

160
	return 0;
161
}
162

163
static void promisor_remote_init(struct repository *r)
164
{
165
	struct promisor_remote_config *config;
166

167
	if (r->promisor_remote_config)
168
		return;
169
	config = r->promisor_remote_config =
170
		xcalloc(1, sizeof(*r->promisor_remote_config));
171
	config->promisors_tail = &config->promisors;
172

173
	repo_config(r, promisor_remote_config, config);
174

175
	if (r->repository_format_partial_clone) {
176
		struct promisor_remote *o, *previous;
177

178
		o = promisor_remote_lookup(config,
179
					   r->repository_format_partial_clone,
180
					   &previous);
181
		if (o)
182
			promisor_remote_move_to_tail(config, o, previous);
183
		else
184
			promisor_remote_new(config, r->repository_format_partial_clone);
185
	}
186
}
187

188
void promisor_remote_clear(struct promisor_remote_config *config)
189
{
190
	while (config->promisors) {
191
		struct promisor_remote *r = config->promisors;
192
		config->promisors = config->promisors->next;
193
		free(r);
194
	}
195

196
	config->promisors_tail = &config->promisors;
197
}
198

199
void repo_promisor_remote_reinit(struct repository *r)
200
{
201
	promisor_remote_clear(r->promisor_remote_config);
202
	FREE_AND_NULL(r->promisor_remote_config);
203
	promisor_remote_init(r);
204
}
205

206
struct promisor_remote *repo_promisor_remote_find(struct repository *r,
207
						  const char *remote_name)
208
{
209
	promisor_remote_init(r);
210

211
	if (!remote_name)
212
		return r->promisor_remote_config->promisors;
213

214
	return promisor_remote_lookup(r->promisor_remote_config, remote_name, NULL);
215
}
216

217
int repo_has_promisor_remote(struct repository *r)
218
{
219
	return !!repo_promisor_remote_find(r, NULL);
220
}
221

222
static int remove_fetched_oids(struct repository *repo,
223
			       struct object_id **oids,
224
			       int oid_nr, int to_free)
225
{
226
	int i, remaining_nr = 0;
227
	int *remaining = xcalloc(oid_nr, sizeof(*remaining));
228
	struct object_id *old_oids = *oids;
229
	struct object_id *new_oids;
230

231
	for (i = 0; i < oid_nr; i++)
232
		if (oid_object_info_extended(repo, &old_oids[i], NULL,
233
					     OBJECT_INFO_SKIP_FETCH_OBJECT)) {
234
			remaining[i] = 1;
235
			remaining_nr++;
236
		}
237

238
	if (remaining_nr) {
239
		int j = 0;
240
		CALLOC_ARRAY(new_oids, remaining_nr);
241
		for (i = 0; i < oid_nr; i++)
242
			if (remaining[i])
243
				oidcpy(&new_oids[j++], &old_oids[i]);
244
		*oids = new_oids;
245
		if (to_free)
246
			free(old_oids);
247
	}
248

249
	free(remaining);
250

251
	return remaining_nr;
252
}
253

254
void promisor_remote_get_direct(struct repository *repo,
255
				const struct object_id *oids,
256
				int oid_nr)
257
{
258
	struct promisor_remote *r;
259
	struct object_id *remaining_oids = (struct object_id *)oids;
260
	int remaining_nr = oid_nr;
261
	int to_free = 0;
262
	int i;
263

264
	if (oid_nr == 0)
265
		return;
266

267
	promisor_remote_init(repo);
268

269
	for (r = repo->promisor_remote_config->promisors; r; r = r->next) {
270
		if (fetch_objects(repo, r->name, remaining_oids, remaining_nr) < 0) {
271
			if (remaining_nr == 1)
272
				continue;
273
			remaining_nr = remove_fetched_oids(repo, &remaining_oids,
274
							 remaining_nr, to_free);
275
			if (remaining_nr) {
276
				to_free = 1;
277
				continue;
278
			}
279
		}
280
		goto all_fetched;
281
	}
282

283
	for (i = 0; i < remaining_nr; i++) {
284
		if (is_promisor_object(&remaining_oids[i]))
285
			die(_("could not fetch %s from promisor remote"),
286
			    oid_to_hex(&remaining_oids[i]));
287
	}
288

289
all_fetched:
290
	if (to_free)
291
		free(remaining_oids);
292
}
293