t0021: implementation the rot13-filter.pl script in C
This script is currently used by three test files: t0021-conversion.sh, t2080-parallel-checkout-basics.sh, and t2082-parallel-checkout-attributes.sh. To avoid the need for the PERL dependency at these tests, let's convert the script to a C test-tool command. The following commit will take care of actually modifying the said tests to use the new C helper and removing the Perl script. The Perl script flushes the log file handler after each write. As commented in [1], this seems to be an early design decision that was later reconsidered, but possibly ended up being left in the code by accident: >> +$debug->flush(); > > Isn't $debug flushed automatically? Maybe, but autoflush is not explicitly enabled. I will enable it again (I disabled it because of Eric's comment but I re-read the comment and he is only talking about pipes). Anyways, this behavior is not really needed for the tests and the flush() calls make the code slightly larger, so let's avoid them altogether in the new C version. [1]: https://lore.kernel.org/git/7F1F1A0E-8FC3-4FBD-81AA-37786DE0EF50@gmail.com/ Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de> Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br> Signed-off-by: Junio C Hamano <gitster@pobox.com>
Matheus Tavares committed
Aug 14, 2022 at 22:06 UTC
52917a998ef3aa38afab59032e49909d92141d27
6 files changed
+396
-2
Makefile
+1
@@ -764,6 +764,7 @@ TEST_BUILTINS_OBJS += test-read-midx.o
764
TEST_BUILTINS_OBJS += test-ref-store.o
765
TEST_BUILTINS_OBJS += test-reftable.o
766
TEST_BUILTINS_OBJS += test-regex.o
767
+TEST_BUILTINS_OBJS += test-rot13-filter.o
768
TEST_BUILTINS_OBJS += test-repository.o
769
TEST_BUILTINS_OBJS += test-revision-walking.o
770
TEST_BUILTINS_OBJS += test-run-command.o
pkt-line.c
+4
-1
@@ -309,7 +309,8 @@ int write_packetized_from_fd_no_flush(int fd_in, int fd_out)
309
return err;
310
}
311
312
-int write_packetized_from_buf_no_flush(const char *src_in, size_t len, int fd_out)
312
+int write_packetized_from_buf_no_flush_count(const char *src_in, size_t len,
313
+ int fd_out, int *packet_counter)
314
{
315
int err = 0;
316
size_t bytes_written = 0;
@@ -324,6 +325,8 @@ int write_packetized_from_buf_no_flush(const char *src_in, size_t len, int fd_ou
325
break;
326
err = packet_write_gently(fd_out, src_in + bytes_written, bytes_to_write);
327
bytes_written += bytes_to_write;
328
+ if (packet_counter)
329
+ (*packet_counter)++;
330
}
331
return err;
332
}
pkt-line.h
+7
-1
@@ -32,7 +32,13 @@ void packet_buf_write(struct strbuf *buf, const char *fmt, ...) __attribute__((f
32
int packet_flush_gently(int fd);
33
int packet_write_fmt_gently(int fd, const char *fmt, ...) __attribute__((format (printf, 2, 3)));
34
int write_packetized_from_fd_no_flush(int fd_in, int fd_out);
35
-int write_packetized_from_buf_no_flush(const char *src_in, size_t len, int fd_out);
35
+int write_packetized_from_buf_no_flush_count(const char *src_in, size_t len,
36
+ int fd_out, int *packet_counter);
37
+static inline int write_packetized_from_buf_no_flush(const char *src_in,
38
+ size_t len, int fd_out)
39
+{
40
+ return write_packetized_from_buf_no_flush_count(src_in, len, fd_out, NULL);
41
+}
42
43
/*
44
* Stdio versions of packet_write functions. When mixing these with fd
t/helper/test-rot13-filter.c
new
+382
@@ -0,0 +1,382 @@
1
+/*
2
+ * Example implementation for the Git filter protocol version 2
3
+ * See Documentation/gitattributes.txt, section "Filter Protocol"
4
+ *
5
+ * Usage: test-tool rot13-filter [--always-delay] --log=<path> <capabilities>
6
+ *
7
+ * Log path defines a debug log file that the script writes to. The
8
+ * subsequent arguments define a list of supported protocol capabilities
9
+ * ("clean", "smudge", etc).
10
+ *
11
+ * When --always-delay is given all pathnames with the "can-delay" flag
12
+ * that don't appear on the list bellow are delayed with a count of 1
13
+ * (see more below).
14
+ *
15
+ * This implementation supports special test cases:
16
+ * (1) If data with the pathname "clean-write-fail.r" is processed with
17
+ * a "clean" operation then the write operation will die.
18
+ * (2) If data with the pathname "smudge-write-fail.r" is processed with
19
+ * a "smudge" operation then the write operation will die.
20
+ * (3) If data with the pathname "error.r" is processed with any
21
+ * operation then the filter signals that it cannot or does not want
22
+ * to process the file.
23
+ * (4) If data with the pathname "abort.r" is processed with any
24
+ * operation then the filter signals that it cannot or does not want
25
+ * to process the file and any file after that is processed with the
26
+ * same command.
27
+ * (5) If data with a pathname that is a key in the delay hash is
28
+ * requested (e.g. "test-delay10.a") then the filter responds with
29
+ * a "delay" status and sets the "requested" field in the delay hash.
30
+ * The filter will signal the availability of this object after
31
+ * "count" (field in delay hash) "list_available_blobs" commands.
32
+ * (6) If data with the pathname "missing-delay.a" is processed that the
33
+ * filter will drop the path from the "list_available_blobs" response.
34
+ * (7) If data with the pathname "invalid-delay.a" is processed that the
35
+ * filter will add the path "unfiltered" which was not delayed before
36
+ * to the "list_available_blobs" response.
37
+ */
38
+
39
+#include "test-tool.h"
40
+#include "pkt-line.h"
41
+#include "string-list.h"
42
+#include "strmap.h"
43
+#include "parse-options.h"
44
+
45
+static FILE *logfile;
46
+static int always_delay, has_clean_cap, has_smudge_cap;
47
+static struct strmap delay = STRMAP_INIT;
48
+
49
+static inline const char *str_or_null(const char *str)
50
+{
51
+ return str ? str : "(null)";
52
+}
53
+
54
+static char *rot13(char *str)
55
+{
56
+ char *c;
57
+ for (c = str; *c; c++)
58
+ if (isalpha(*c))
59
+ *c += tolower(*c) < 'n' ? 13 : -13;
60
+ return str;
61
+}
62
+
63
+static char *get_value(char *buf, const char *key)
64
+{
65
+ const char *orig_buf = buf;
66
+ if (!buf ||
67
+ !skip_prefix((const char *)buf, key, (const char **)&buf) ||
68
+ !skip_prefix((const char *)buf, "=", (const char **)&buf) ||
69
+ !*buf)
70
+ die("expected key '%s', got '%s'", key, str_or_null(orig_buf));
71
+ return buf;
72
+}
73
+
74
+/*
75
+ * Read a text packet, expecting that it is in the form "key=value" for
76
+ * the given key. An EOF does not trigger any error and is reported
77
+ * back to the caller with NULL. Die if the "key" part of "key=value" does
78
+ * not match the given key, or the value part is empty.
79
+ */
80
+static char *packet_key_val_read(const char *key)
81
+{
82
+ char *buf;
83
+ if (packet_read_line_gently(0, NULL, &buf) < 0)
84
+ return NULL;
85
+ return xstrdup(get_value(buf, key));
86
+}
87
+
88
+static inline void assert_remote_capability(struct strset *caps, const char *cap)
89
+{
90
+ if (!strset_contains(caps, cap))
91
+ die("required '%s' capability not available from remote", cap);
92
+}
93
+
94
+static void read_capabilities(struct strset *remote_caps)
95
+{
96
+ for (;;) {
97
+ char *buf = packet_read_line(0, NULL);
98
+ if (!buf)
99
+ break;
100
+ strset_add(remote_caps, get_value(buf, "capability"));
101
+ }
102
+
103
+ assert_remote_capability(remote_caps, "clean");
104
+ assert_remote_capability(remote_caps, "smudge");
105
+ assert_remote_capability(remote_caps, "delay");
106
+}
107
+
108
+static void check_and_write_capabilities(struct strset *remote_caps,
109
+ const char **caps, int nr_caps)
110
+{
111
+ int i;
112
+ for (i = 0; i < nr_caps; i++) {
113
+ if (!strset_contains(remote_caps, caps[i]))
114
+ die("our capability '%s' is not available from remote",
115
+ caps[i]);
116
+ packet_write_fmt(1, "capability=%s\n", caps[i]);
117
+ }
118
+ packet_flush(1);
119
+}
120
+
121
+struct delay_entry {
122
+ int requested, count;
123
+ char *output;
124
+};
125
+
126
+static void free_delay_entries(void)
127
+{
128
+ struct hashmap_iter iter;
129
+ struct strmap_entry *ent;
130
+
131
+ strmap_for_each_entry(&delay, &iter, ent) {
132
+ struct delay_entry *delay_entry = ent->value;
133
+ free(delay_entry->output);
134
+ free(delay_entry);
135
+ }
136
+ strmap_clear(&delay, 0);
137
+}
138
+
139
+static void add_delay_entry(char *pathname, int count, int requested)
140
+{
141
+ struct delay_entry *entry = xcalloc(1, sizeof(*entry));
142
+ entry->count = count;
143
+ entry->requested = requested;
144
+ if (strmap_put(&delay, pathname, entry))
145
+ BUG("adding the same path twice to delay hash?");
146
+}
147
+
148
+static void reply_list_available_blobs_cmd(void)
149
+{
150
+ struct hashmap_iter iter;
151
+ struct strmap_entry *ent;
152
+ struct string_list_item *str_item;
153
+ struct string_list paths = STRING_LIST_INIT_NODUP;
154
+
155
+ /* flush */
156
+ if (packet_read_line(0, NULL))
157
+ die("bad list_available_blobs end");
158
+
159
+ strmap_for_each_entry(&delay, &iter, ent) {
160
+ struct delay_entry *delay_entry = ent->value;
161
+ if (!delay_entry->requested)
162
+ continue;
163
+ delay_entry->count--;
164
+ if (!strcmp(ent->key, "invalid-delay.a")) {
165
+ /* Send Git a pathname that was not delayed earlier */
166
+ packet_write_fmt(1, "pathname=unfiltered");
167
+ }
168
+ if (!strcmp(ent->key, "missing-delay.a")) {
169
+ /* Do not signal Git that this file is available */
170
+ } else if (!delay_entry->count) {
171
+ string_list_append(&paths, ent->key);
172
+ packet_write_fmt(1, "pathname=%s", ent->key);
173
+ }
174
+ }
175
+
176
+ /* Print paths in sorted order. */
177
+ string_list_sort(&paths);
178
+ for_each_string_list_item(str_item, &paths)
179
+ fprintf(logfile, " %s", str_item->string);
180
+ string_list_clear(&paths, 0);
181
+
182
+ packet_flush(1);
183
+
184
+ fprintf(logfile, " [OK]\n");
185
+ packet_write_fmt(1, "status=success");
186
+ packet_flush(1);
187
+}
188
+
189
+static void command_loop(void)
190
+{
191
+ for (;;) {
192
+ char *buf, *output;
193
+ char *pathname;
194
+ struct delay_entry *entry;
195
+ struct strbuf input = STRBUF_INIT;
196
+ char *command = packet_key_val_read("command");
197
+
198
+ if (!command) {
199
+ fprintf(logfile, "STOP\n");
200
+ break;
201
+ }
202
+ fprintf(logfile, "IN: %s", command);
203
+
204
+ if (!strcmp(command, "list_available_blobs")) {
205
+ reply_list_available_blobs_cmd();
206
+ free(command);
207
+ continue;
208
+ }
209
+
210
+ pathname = packet_key_val_read("pathname");
211
+ if (!pathname)
212
+ die("unexpected EOF while expecting pathname");
213
+ fprintf(logfile, " %s", pathname);
214
+
215
+ /* Read until flush */
216
+ while ((buf = packet_read_line(0, NULL))) {
217
+ if (!strcmp(buf, "can-delay=1")) {
218
+ entry = strmap_get(&delay, pathname);
219
+ if (entry && !entry->requested)
220
+ entry->requested = 1;
221
+ else if (!entry && always_delay)
222
+ add_delay_entry(pathname, 1, 1);
223
+ } else if (starts_with(buf, "ref=") ||
224
+ starts_with(buf, "treeish=") ||
225
+ starts_with(buf, "blob=")) {
226
+ fprintf(logfile, " %s", buf);
227
+ } else {
228
+ /*
229
+ * In general, filters need to be graceful about
230
+ * new metadata, since it's documented that we
231
+ * can pass any key-value pairs, but for tests,
232
+ * let's be a little stricter.
233
+ */
234
+ die("Unknown message '%s'", buf);
235
+ }
236
+ }
237
+
238
+ read_packetized_to_strbuf(0, &input, 0);
239
+ fprintf(logfile, " %"PRIuMAX" [OK] -- ", (uintmax_t)input.len);
240
+
241
+ entry = strmap_get(&delay, pathname);
242
+ if (entry && entry->output) {
243
+ output = entry->output;
244
+ } else if (!strcmp(pathname, "error.r") || !strcmp(pathname, "abort.r")) {
245
+ output = "";
246
+ } else if (!strcmp(command, "clean") && has_clean_cap) {
247
+ output = rot13(input.buf);
248
+ } else if (!strcmp(command, "smudge") && has_smudge_cap) {
249
+ output = rot13(input.buf);
250
+ } else {
251
+ die("bad command '%s'", command);
252
+ }
253
+
254
+ if (!strcmp(pathname, "error.r")) {
255
+ fprintf(logfile, "[ERROR]\n");
256
+ packet_write_fmt(1, "status=error");
257
+ packet_flush(1);
258
+ } else if (!strcmp(pathname, "abort.r")) {
259
+ fprintf(logfile, "[ABORT]\n");
260
+ packet_write_fmt(1, "status=abort");
261
+ packet_flush(1);
262
+ } else if (!strcmp(command, "smudge") &&
263
+ (entry = strmap_get(&delay, pathname)) &&
264
+ entry->requested == 1) {
265
+ fprintf(logfile, "[DELAYED]\n");
266
+ packet_write_fmt(1, "status=delayed");
267
+ packet_flush(1);
268
+ entry->requested = 2;
269
+ if (entry->output != output) {
270
+ free(entry->output);
271
+ entry->output = xstrdup(output);
272
+ }
273
+ } else {
274
+ int i, nr_packets = 0;
275
+ size_t output_len;
276
+ const char *p;
277
+ packet_write_fmt(1, "status=success");
278
+ packet_flush(1);
279
+
280
+ if (skip_prefix(pathname, command, &p) &&
281
+ !strcmp(p, "-write-fail.r")) {
282
+ fprintf(logfile, "[WRITE FAIL]\n");
283
+ die("%s write error", command);
284
+ }
285
+
286
+ output_len = strlen(output);
287
+ fprintf(logfile, "OUT: %"PRIuMAX" ", (uintmax_t)output_len);
288
+
289
+ if (write_packetized_from_buf_no_flush_count(output,
290
+ output_len, 1, &nr_packets))
291
+ die("failed to write buffer to stdout");
292
+ packet_flush(1);
293
+
294
+ for (i = 0; i < nr_packets; i++)
295
+ fprintf(logfile, ".");
296
+ fprintf(logfile, " [OK]\n");
297
+
298
+ packet_flush(1);
299
+ }
300
+ free(pathname);
301
+ strbuf_release(&input);
302
+ free(command);
303
+ }
304
+}
305
+
306
+static void packet_initialize(void)
307
+{
308
+ char *pkt_buf = packet_read_line(0, NULL);
309
+
310
+ if (!pkt_buf || strcmp(pkt_buf, "git-filter-client"))
311
+ die("bad initialize: '%s'", str_or_null(pkt_buf));
312
+
313
+ pkt_buf = packet_read_line(0, NULL);
314
+ if (!pkt_buf || strcmp(pkt_buf, "version=2"))
315
+ die("bad version: '%s'", str_or_null(pkt_buf));
316
+
317
+ pkt_buf = packet_read_line(0, NULL);
318
+ if (pkt_buf)
319
+ die("bad version end: '%s'", pkt_buf);
320
+
321
+ packet_write_fmt(1, "git-filter-server");
322
+ packet_write_fmt(1, "version=2");
323
+ packet_flush(1);
324
+}
325
+
326
+static const char *rot13_usage[] = {
327
+ "test-tool rot13-filter [--always-delay] --log=<path> <capabilities>",
328
+ NULL
329
+};
330
+
331
+int cmd__rot13_filter(int argc, const char **argv)
332
+{
333
+ int i, nr_caps;
334
+ struct strset remote_caps = STRSET_INIT;
335
+ const char *log_path = NULL;
336
+
337
+ struct option options[] = {
338
+ OPT_BOOL(0, "always-delay", &always_delay,
339
+ "delay all paths with the can-delay flag"),
340
+ OPT_STRING(0, "log", &log_path, "path",
341
+ "path to the debug log file"),
342
+ OPT_END()
343
+ };
344
+ nr_caps = parse_options(argc, argv, NULL, options, rot13_usage,
345
+ PARSE_OPT_STOP_AT_NON_OPTION);
346
+
347
+ if (!log_path || !nr_caps)
348
+ usage_with_options(rot13_usage, options);
349
+
350
+ logfile = fopen(log_path, "a");
351
+ if (!logfile)
352
+ die_errno("failed to open log file");
353
+
354
+ for (i = 0; i < nr_caps; i++) {
355
+ if (!strcmp(argv[i], "smudge"))
356
+ has_smudge_cap = 1;
357
+ if (!strcmp(argv[i], "clean"))
358
+ has_clean_cap = 1;
359
+ }
360
+
361
+ add_delay_entry("test-delay10.a", 1, 0);
362
+ add_delay_entry("test-delay11.a", 1, 0);
363
+ add_delay_entry("test-delay20.a", 2, 0);
364
+ add_delay_entry("test-delay10.b", 1, 0);
365
+ add_delay_entry("missing-delay.a", 1, 0);
366
+ add_delay_entry("invalid-delay.a", 1, 0);
367
+
368
+ fprintf(logfile, "START\n");
369
+ packet_initialize();
370
+
371
+ read_capabilities(&remote_caps);
372
+ check_and_write_capabilities(&remote_caps, argv, nr_caps);
373
+ fprintf(logfile, "init handshake complete\n");
374
+ strset_clear(&remote_caps);
375
+
376
+ command_loop();
377
+
378
+ if (fclose(logfile))
379
+ die_errno("error closing logfile");
380
+ free_delay_entries();
381
+ return 0;
382
+}
t/helper/test-tool.c
+1
@@ -65,6 +65,7 @@ static struct test_cmd cmds[] = {
65
{ "read-midx", cmd__read_midx },
66
{ "ref-store", cmd__ref_store },
67
{ "reftable", cmd__reftable },
68
+ { "rot13-filter", cmd__rot13_filter },
69
{ "dump-reftable", cmd__dump_reftable },
70
{ "regex", cmd__regex },
71
{ "repository", cmd__repository },
t/helper/test-tool.h
+1
@@ -54,6 +54,7 @@ int cmd__read_cache(int argc, const char **argv);
54
int cmd__read_graph(int argc, const char **argv);
55
int cmd__read_midx(int argc, const char **argv);
56
int cmd__ref_store(int argc, const char **argv);
57
+int cmd__rot13_filter(int argc, const char **argv);
58
int cmd__reftable(int argc, const char **argv);
59
int cmd__regex(int argc, const char **argv);
60
int cmd__repository(int argc, const char **argv);