cat-file: add a --stdin-cmd mode
RFC v3 1/1 cat-file: add a --stdin-cmd mode
This RFC patch proposes a new flag --batch-command that works with git-cat-file --batch. Similar to git-update-ref --stdin, it will accept commands and arguments from stdin.
The start of this idea was discussed in [1], where the original motivation was to be able to control when the buffer was flushed to stdout in --buffer mode.
However, this can actually be much more useful in situations when git-cat-file --batch is being used as a long lived backend query process. At GitLab, we use a pair of cat-file processes. One for iterating over object metadata with --batch-check, and the other to grab object contents with --batch. However, if we had --batch-command, we could get rid of the second --batch-check process, and just have one process where we can flip between getting object info, and getting object contents. This can lead to huge savings since on a given server there could be hundreds to thousands of git cat-file processes at a time.
git cat-file --batch-command
$ <command> [arg1] [arg2] NL
This patch adds three commands: object, info, fflush
$ object <sha1> NL $ info <sha1> NL $ fflush NL
These three would be immediately useful in GitLab's context, but one can imagine this mode to be further extended for other things.
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.
This would be the first step in adding such an interface to git-cat-file.
[1] https://lore.kernel.org/git/[email protected]/
---
Taylor, I'd be interested in your thoughts on this proposal since you helped review the previous patch that turned into this RFC. Thanks!
Changes from v2:
- refactored tests to be within run_tests()
- added a test to test --buffer behavior with fflush
- cleaned up cat-file.c: clarified var names, removed unnecessary code based on suggestions from Phillip Wood
- removed strvec changes
Changes from v1:
- changed option name to batch-command.
- changed command function interface to receive the whole line after the command name to put the onus of parsing arguments to each individual command function.
- pass in whole line to batch_one_object in both parse_cmd_object and parse_cmd_info to support spaces in the object reference.
- removed addition of -z to include in a separate patch series
- added documentation.
--- Documentation/git-cat-file.txt | 15 +++++ builtin/cat-file.c | 114 +++++++++++++++++++++++++++++++-- t/t1006-cat-file.sh | 83 ++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 7 deletions(-)
Documentation/git-cat-file.txt +15 -0
@@ -96,6 +96,21 @@ OPTIONS need to specify the path, separated by whitespace. See the section `BATCH OUTPUT` below for details. +--batch-command:: + Enter a command mode that reads from stdin. May not be combined with any + other options or arguments except `--textconv` or `--filters`, in which + case the input lines also need to specify the path, separated by + whitespace. See the section `BATCH OUTPUT` below for details. + +object <object>:: + Print object contents for object reference <object> + +info <object>:: + Print object info for object reference <object> + +flush:: + Flush to stdout immediately when used with --buffer + --batch-all-objects:: Instead of reading a list of objects on stdin, perform the requested batch operation on all objects in the repository and
builtin/cat-file.c +107 -7
186 lines not on this page · raw message
t/t1006-cat-file.sh +83 -0
117 lines not on this page · raw message
Signature · 1 line
2.34.1
Quoted 5 lines · John Cai
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.
I think the full hash is actually revision name.
Signature · 1 line
An old man doll... just what I always wanted! - Clara
Quoted 8 lines · Bagas Sanjaya
Quoted 5 lines · John Cai
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.I think the full hash is actually revision name.
There is no entry for "revision name" in Documentation/glossary-content.txt ;-)
But to John, if you have a loop that feedseach line to get_oid(),
while (getline(buf)) {
struct object_id oid;
if (get_oid(buf, &oid))
warn and continue;
use oid;
}is it much slower than a mode that can ONLY handle a full object name input, i.e.
while (getline(buf)) {
struct object_id oid;
if (get_oid_hex(buf, &oid))
warn and continue;
use oid;
}when your input is restricted to full object names?
get_oid() == repo_get_oid()
-> get_oid_with_context()
-> get_oid_with_context_1()
-> get_oid_1() -> peel_onion() -> get_oid_basic() -> get_oid_hex() -> repo_dwim_ref()
it seems that warn_ambiguous_refs and warn_on_object_refname_ambiguity we would waste time on refname discovery but I see cat-file already has some provision to disable this check. So when we do not need to call repo_dwim_ref(), do we still spend measurable cycles in this callchain?
Quoted 3 lines · John Cai
This RFC patch proposes a new flag --batch-command that works with git-cat-file --batch.
The subject is "Re: [RFC v3] cat-file: add a --stdin-cmd mode" and now you are talking about '--batch-command' instead of '--stdin-cmd'.
"that works with git-cat-file --batch" is not very clear. Maybe you could find a wording that explains better how --batch-command is different from --batch.
Also I think at this point this should probably not be an RFC patch anymore but a regular one.
Quoted 6 lines
Similar to git-update-ref --stdin, it will accept
commands and arguments from stdin.The start of this idea was discussed in [1], where the original motivation was to be able to control when the buffer was flushed to stdout in --buffer mode.
That would be nice in a cover letter but I am not sure a commit message is the right place for this.
Quoted 6 lines
However, this can actually be much more useful in situations when git-cat-file --batch is being used as a long lived backend query process. At GitLab, we use a pair of cat-file processes. One for iterating over object metadata with --batch-check, and the other to grab object contents with --batch. However, if we had --batch-command, we could get rid of the second --batch-check process,
Maybe s/second// would make it clear that there are no two --batch-command processes.
Quoted 4 lines
and just have one process
where we can flip between getting object info, and getting object contents. This can lead to huge savings since on a given server there could be hundreds to thousands of git cat-file processes at a time.
It's not clear if all the git cat-file processes you are talking about are mostly --batch-check processes or --batch processes, or a roughly equal amount of both. My guess is the latter and that --batch-command would mean that there would be around two times fewer cat-file processes.
Quoted 3 lines
git cat-file --batch-command
$ <command> [arg1] [arg2] NL
It's a bit unclear what the 2 above lines mean. Maybe you could add a small explanation like for example "The new flag can be used like this:" and "It receives commands from stdin in the format:"
Also not sure why there is a '$' char in front of '<command> [arg1] [arg2] NL' but not in front of 'git cat-file --batch-command'. It doesn't look like in the 'git update-ref --stdin' doc that '$' are used in front of the commands that can be passed through stdin.
Quoted 1 line
This patch adds three commands: object, info, fflush
Maybe s/three commands/the following first three commands/
Quoted 3 lines
$ object <sha1> NL $ info <sha1> NL $ fflush NL
Idem about '$'.
Quoted 2 lines
These three would be immediately useful in GitLab's context, but one can imagine this mode to be further extended for other things.
Not very clear which "mode" you are talking about. You have been talking about a mode only in the subject so far. Maybe you should talk a bit about that above when '<command> [arg1] [arg2] NL' is introduced.
Also you don't talk about the output format. --batch and --batch-check accept [=<format>], but it looks like --batch-command doesn't.
Quoted 5 lines
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.
In a cover letter that would be ok, but I am not sure that a commit message is the best place for this kind of details about future work.
Quoted 40 lines
This would be the first step in adding such an interface to git-cat-file.
[1] https://lore.kernel.org/git/[email protected]/
Signed-off-by John Cai <[email protected]>---
Taylor, I'd be interested in your thoughts on this proposal since you helped review the previous patch that turned into this RFC. Thanks!
Changes from v2:
- refactored tests to be within
run_tests()
- added a test to test --buffer behavior with fflush
- cleaned upcat-file.c: clarified var names, removed unnecessary code based on suggestions from Phillip Wood
- removed strvec changesChanges from v1:
- changed option name to batch-command.
- changed command function interface to receive the whole line after the command name to put the onus of parsing arguments to each individual command function.
- pass in whole line tobatch_one_objectin bothparse_cmd_objectandparse_cmd_infoto support spaces in the object reference.
- removed addition of -z to include in a separate patch series
- added documentation.--- Documentation/git-cat-file.txt | 15 +++++ builtin/cat-file.c | 114 +++++++++++++++++++++++++++++++-- t/t1006-cat-file.sh | 83 ++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 7 deletions(-)Documentation/git-cat-file.txt +0
-0
Documentation/git-cat-file.txt OPTIONS · line 100
Quoted 5 lines
Documentation/git-cat-file.txt +2
-0@@ -96,6 +96,21 @@ OPTIONS need to specify the path, separated by whitespace. See the section `BATCH OUTPUT` below for details. +--batch-command:: + Enter a command mode that reads from stdin.
Maybe s/a command mode that reads from stdin/a mode that reads commands from stdin/
Also I would expect something about the output, like perhaps "...and ouputs the command results to stdout".
Documentation/git-cat-file.txt OPTIONS · line 103
Quoted 4 lines
May not be combined with any
Documentation/git-cat-file.txt +3
-0+ other options or arguments except `--textconv` or `--filters`, in which + case the input lines also need to specify the path, separated by + whitespace. See the section `BATCH OUTPUT` below for details.
The BATCH OUTPUT section says that a format can be passed but that doesn't seem to be the case with --batch-command. So you might need to make some changes to that section too or add a bit more details about the output here.
Quoted 17 lines
Documentation/git-cat-file.txt +9
-0+object <object>:: + Print object contents for object reference <object> + +info <object>:: + Print object info for object reference <object> + +flush:: + Flush to stdout immediately when used with --buffer + --batch-all-objects:: Instead of reading a list of objects on stdin, perform the requested batch operation on all objects in the repository andbuiltin/cat-file.c +0
-0
builtin/cat-file.c struct batch_options { · line 30
Quoted 8 lines
builtin/cat-file.c +2
-1@@ -24,9 +24,11 @@ struct batch_options {int buffer_output;int all_objects;int unordered; -int cmdmode;/* may be 'w' or 'c' for --filters or --textconv */ +int mode;/* may be 'w' or 'c' for --filters or --textconv */ const char *format; +int command; };
Maybe add a blank line here.
builtin/cat-file.c static void print_object_or_die(struct batch_options *opt, struct expand_data *d · line 307
Quoted 10 lines
builtin/cat-file.c +2
-1+static char line_termination ='\n' ;static const char *force_path;@@ -302,19 +304,19 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *dif (data->type ==OBJ_BLOB ) {if (opt->buffer_output)fflush (stdout); -if (opt->cmdmode) { +if (opt->mode) {
The mechanical s/cmdmode/mode/g change could have been made in a preparatory patch to make this patch a bit smaller and easier to digest.
Quoted 26 lines
builtin/cat-file.c +26
-0+static void batch_objects_command (struct batch_options *opt, +struct strbuf *output, +struct expand_data *data) +{ +struct strbuf input =STRBUF_INIT ; + +/* Read each line dispatch its command */ +while (!strbuf_getwholeline (&input, stdin, line_termination)) { +int i; +const struct parse_cmd *cmd =NULL ; +const char *p, *cmd_end; + +if (*input.buf == line_termination) +die ("empty command in input" ); +else if (isspace (*input.buf)) +die ("whitespace before command: %s" , input.buf); + +for (i =0 ; i <ARRAY_SIZE (commands); i++) { +const char *prefix = commands[i].prefix; +char c; +if (!skip_prefix (input.buf, prefix, &cmd_end)) +continue ; +/* +* If the command has arguments, verify that it's +* followed by a space. Otherwise, it shall be followed +* by a line terminator.
builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 587
Quoted 10 lines
builtin/cat-file.c +10
-0+*/ + c = commands[i].takes_args ?' ' : line_termination; +if (input.buf[strlen (prefix)] != c) +die ("arguments invalid for command: %s" , commands[i].prefix); + + cmd = &commands[i]; +if (cmd->takes_args) { + p = cmd_end +1 ; +// strip newline before handing it to the +// handling function
So above the /* */ comments delimiters are used but here // is used. I am not sure we support // these days, but if we do, I think it would be better to avoid mixing comment styles in the same function.
Quoted 15 lines
builtin/cat-file.c +13
-0+ input.buf[strcspn (input.buf,"\n" )] ='\0' ; + } + +break ; + } + +if (!cmd) +die ("unknown command: %s" , input.buf); + + cmd->fn (opt, p, output, data); + } +strbuf_release (&input); +}
builtin/cat-file.c static int batch_objects(struct batch_options *opt) · line 688
Quoted 7 lines
builtin/cat-file.c +3
-0@@ -590,6 +682,9 @@ static int batch_objects(struct batch_options *opt) save_warning = warn_on_object_refname_ambiguity; warn_on_object_refname_ambiguity =0 ; +if (command) +batch_objects_command (opt, &output, &data); +while (strbuf_getline (&input, stdin) !=EOF ) {
I think batch_objects_command() will consume everything from stdin, so it doesn't make sense to try to read again from stdin after it. Maybe the whole while (...) { ... } clause should be inside an else clause or something.
Quoted 10 lines
builtin/cat-file.c +1
-0if (data.split_on_whitespace) {/* @@ -636,6 +731,7 @@ static int batch_option_callback(const struct option *opt, bo->enabled =1 ; bo->print_contents = !strcmp (opt->long_name,"batch" ); + bo->command = !strcmp (opt->long_name,"batch-command" ); bo->format = arg;return 0 ;
Quoted 44 lines · Junio C Hamano
Quoted 8 lines · Bagas Sanjaya
Quoted 5 lines · John Cai
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.I think the full hash is actually revision name.
There is no entry for "revision name" in
Documentation/glossary-content.txt;-)But to John, if you have a loop that feedseach line to
get_oid(),while (getline(buf)) { struct object_id oid; if (get_oid(buf, &oid)) warn and continue; use oid; }is it much slower than a mode that can ONLY handle a full object name input, i.e.
while (getline(buf)) { struct object_id oid; if (get_oid_hex(buf, &oid)) warn and continue; use oid; }when your input is restricted to full object names?
get_oid()==repo_get_oid()
->get_oid_with_context()
->get_oid_with_context_1()-> get_oid_1() -> peel_onion() -> get_oid_basic() -> get_oid_hex() -> repo_dwim_ref()
Quoted 5 lines
it seems that
warn_ambiguous_refsandwarn_on_object_refname_ambiguitywe would waste time on refname discovery but I see cat-file already has some provision to disable this check. So when we do not need to callrepo_dwim_ref(), do we still spend measurable cycles in this callchain?
For what it's worth I think this claim that we spend a non-trivial amount of time on the difference between these two comes from me originally. I'd had a chat with John about various things to try out in such a "cat-file --batch" mode, and this was one of those things.
I tried instrumenting the relevant code in builtin/cat-file.c the other (but forgot to reply to this thread), and whatever I'd found there at the time (this was weeks/months ago) I couldn't reproduce.
So there's probably nothing worthwhile to check out here, i.e. the trivial cost of get_oid_with_context() is probably nothing to worry about.
Hi John
Quoted 22 lines · John Cai
This RFC patch proposes a new flag --batch-command that works with git-cat-file --batch. Similar to git-update-ref --stdin, it will accept commands and arguments from stdin.
The start of this idea was discussed in [1], where the original motivation was to be able to control when the buffer was flushed to stdout in --buffer mode.
However, this can actually be much more useful in situations when git-cat-file --batch is being used as a long lived backend query process. At GitLab, we use a pair of cat-file processes. One for iterating over object metadata with --batch-check, and the other to grab object contents with --batch. However, if we had --batch-command, we could get rid of the second --batch-check process, and just have one process where we can flip between getting object info, and getting object contents. This can lead to huge savings since on a given server there could be hundreds to thousands of git cat-file processes at a time.
git cat-file --batch-command
$ <command> [arg1] [arg2] NL
Quoted 8 lines
This patch adds three commands: object, info, fflush
$ object <sha1> NL $ info <sha1> NL $ fflush NLThese three would be immediately useful in GitLab's context, but one can imagine this mode to be further extended for other things.
I think this is moving in the right direction, I've left some comments below.
Quoted 52 lines
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.This would be the first step in adding such an interface to git-cat-file.
[1] https://lore.kernel.org/git/[email protected]/
Signed-off-by John Cai <[email protected]>---
Taylor, I'd be interested in your thoughts on this proposal since you helped review the previous patch that turned into this RFC. Thanks!
Changes from v2:
- refactored tests to be within
run_tests()
- added a test to test --buffer behavior with fflush
- cleaned upcat-file.c: clarified var names, removed unnecessary code based on suggestions from Phillip Wood
- removed strvec changesChanges from v1:
- changed option name to batch-command.
- changed command function interface to receive the whole line after the command name to put the onus of parsing arguments to each individual command function.
- pass in whole line tobatch_one_objectin bothparse_cmd_objectandparse_cmd_infoto support spaces in the object reference.
- removed addition of -z to include in a separate patch series
- added documentation.--- Documentation/git-cat-file.txt | 15 +++++ builtin/cat-file.c | 114 +++++++++++++++++++++++++++++++-- t/t1006-cat-file.sh | 83 ++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 7 deletions(-)Documentation/git-cat-file.txt +3
-0@@ -96,6 +96,21 @@ OPTIONS need to specify the path, separated by whitespace. See the section `BATCH OUTPUT` below for details. +--batch-command:: + Enter a command mode that reads from stdin. May not be combined with any + other options or arguments except `--textconv` or `--filters`, in which
Documentation/git-cat-file.txt OPTIONS · line 111
Quoted 10 lines
Documentation/git-cat-file.txt +10
-0+ case the input lines also need to specify the path, separated by + whitespace. See the section `BATCH OUTPUT` below for details. + +object <object>:: + Print object contents for object reference <object> + +info <object>:: + Print object info for object reference <object> + +flush::
I think this is a better name than fflush as calling fflush is just an implementation detail. I've been thinking about this and have some concerns with the current implementation as it allows the caller to force a flush but the output may be flushed at other times and so it does not allow for deadlock free reading and writing to cat-file from a single process. If instead we buffered the input lines and only processed then when we received a flush command it would be easy to read and write to cat-file from a single process without deadlocks. This would mean that callers would have to add flush commands to get any output before they closed the pipe writing to cat-file.
Quoted 10 lines
Documentation/git-cat-file.txt +2
-0+ Flush to stdout immediately when used with --buffer + --batch-all-objects:: Instead of reading a list of objects on stdin, perform the requested batch operation on all objects in the repository andbuiltin/cat-file.c +0
-0
builtin/cat-file.c struct batch_options { · line 27
Quoted 5 lines
builtin/cat-file.c +1
-1@@ -24,9 +24,11 @@ struct batch_options {int buffer_output;int all_objects;int unordered; -int cmdmode;/* may be 'w' or 'c' for --filters or --textconv */ +int mode;/* may be 'w' or 'c' for --filters or --textconv */
If you really need to rename this variable then doing that in a separate preparatory patch would make this easier to review as it separates out two separate sets of changes.
builtin/cat-file.c struct batch_options { · line 29
Quoted 2 lines
builtin/cat-file.c +1
-0const char *format; +int command;
Can't we just call this batch_command and leave cmdmode alone? I don't know maybe cmdmode would be confused with having something to do with batch_command then.
builtin/cat-file.c struct batch_options { · line 31
Quoted 2 lines
builtin/cat-file.c +1
-0}; +static char line_termination ='\n' ;
This seems unnecessary as it is the only permitted line ending
Quoted 96 lines
builtin/cat-file.c +62
-4static const char *force_path;@@ -302,19 +304,19 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *d if (data->type == OBJ_BLOB) { if (opt->buffer_output) fflush(stdout); - if (opt->cmdmode) { + if (opt->mode) { char *contents; unsigned long size; if (!data->rest) die("missing path for '%s'", oid_to_hex(oid)); - if (opt->cmdmode == 'w') { + if (opt->mode == 'w') { if (filter_object(data->rest, 0100644, oid, &contents, &size)) die("could not convert '%s' %s", oid_to_hex(oid), data->rest); - } else if (opt->cmdmode == 'c') { + } else if (opt->mode == 'c') { enum object_type type; if (!textconv_object(the_repository, data->rest, 0100644, oid,@@ -326,7 +328,7 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *ddie ("could not convert '%s' %s" ,oid_to_hex (oid), data->rest); }else -BUG ("invalid cmdmode: %c" , opt->cmdmode); +BUG ("invalid mode: %c" , opt->mode);batch_write (opt, contents, size);free (contents); }else {@@ -508,6 +510,95 @@ static int batch_unordered_packed(const struct object_id *oid, data); } +static void parse_cmd_object (struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ + opt->print_contents =1 ; +batch_one_object (line, output, opt, data); +} + +static void parse_cmd_info (struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ + opt->print_contents =0 ; +batch_one_object (line, output, opt, data); +} + +static void parse_cmd_fflush (struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ +fflush (stdout); +} + +typedef void (*parse_cmd_fn_t )(struct batch_options *,const char *, +struct strbuf *,struct expand_data *); + +static const struct parse_cmd { +const char *prefix; +parse_cmd_fn_t fn; +unsigned takes_args; +} commands[] = { + {"object" , parse_cmd_object,1 }, + {"info" , parse_cmd_info,1 }, + {"fflush" , parse_cmd_fflush,0 }, +}; + +static void batch_objects_command (struct batch_options *opt, +struct strbuf *output, +struct expand_data *data) +{ +struct strbuf input =STRBUF_INIT ; + +/* Read each line dispatch its command */ +while (!strbuf_getwholeline (&input, stdin, line_termination)) { +int i; +const struct parse_cmd *cmd =NULL ; +const char *p, *cmd_end; + +if (*input.buf == line_termination) +die ("empty command in input" ); +else if (isspace (*input.buf)) +die ("whitespace before command: %s" , input.buf); + +for (i =0 ; i <ARRAY_SIZE (commands); i++) { +const char *prefix = commands[i].prefix;
builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 580
Quoted 10 lines
builtin/cat-file.c +10
-0+char c; +if (!skip_prefix (input.buf, prefix, &cmd_end)) +continue ; +/* +* If the command has arguments, verify that it's +* followed by a space. Otherwise, it shall be followed +* by a line terminator. +*/ + c = commands[i].takes_args ?' ' : line_termination; +if (input.buf[strlen (prefix)] != c)
As I pointed out in the last round you can use cmd_end here rather than calling strlen. I've just noticed that this will fail for a command that does not take arguments when the last input line does not end with '\n'. I think
if (*cmd_end && *cmd_end != c)
would be safer
builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 588
Quoted 8 lines
builtin/cat-file.c +8
-0+die ("arguments invalid for command: %s" , commands[i].prefix); + + cmd = &commands[i]; +if (cmd->takes_args) { + p = cmd_end +1 ; +// strip newline before handing it to the +// handling function + input.buf[strcspn (input.buf,"\n" )] ='\0' ;
When I suggested replacing strstr() last time I failed to notice that we
know that if there is a newline character it is at input.buf[len - 1]
so we don't need to scan the whole string to find it.
if (input.buf[input.len - 1] == '\n') input.buf[--buf.len] = '\0';
(feel free to change it to avoid the prefix operator)
Quoted 34 lines
builtin/cat-file.c +15
-1+ } + +break ; + } + +if (!cmd) +die ("unknown command: %s" , input.buf); + + cmd->fn (opt, p, output, data); + } +strbuf_release (&input); +} +static int batch_objects (struct batch_options *opt) {struct strbuf input =STRBUF_INIT ;@@ -515,6 +606,7 @@ static int batch_objects(struct batch_options *opt)struct expand_data data;int save_warning;int retval =0 ; +const int command = opt->command;if (!opt->format) opt->format ="%(objectname) %(objecttype) %(objectsize)" ;@@ -529,7 +621,7 @@ static int batch_objects(struct batch_options *opt)strbuf_expand (&output, opt->format, expand_format, &data); data.mark_query =0 ;strbuf_release (&output); -if (opt->cmdmode) +if (opt->mode) data.split_on_whitespace =1 ;/*
builtin/cat-file.c static int batch_objects(struct batch_options *opt) · line 687
Quoted 6 lines
builtin/cat-file.c +3
-0@@ -590,6 +682,9 @@ static int batch_objects(struct batch_options *opt) save_warning = warn_on_object_refname_ambiguity; warn_on_object_refname_ambiguity =0 ; +if (command) +batch_objects_command (opt, &output, &data); +
Moving this is good as we no longer need to touch the line below
Quoted 36 lines
builtin/cat-file.c +6
-1while (strbuf_getline (&input, stdin) !=EOF ) {if (data.split_on_whitespace) {/* @@ -636,6 +731,7 @@ static int batch_option_callback(const struct option *opt, bo->enabled =1 ; bo->print_contents = !strcmp (opt->long_name,"batch" ); + bo->command = !strcmp (opt->long_name,"batch-command" ); bo->format = arg;return 0 ;@@ -683,6 +779,10 @@ int cmd_cat_file(int argc, const char **argv, const char *prefix) N_("like --batch, but don't emit <contents>"), PARSE_OPT_OPTARG | PARSE_OPT_NONEG, batch_option_callback), +OPT_CALLBACK_F (0 ,"batch-command" , &batch,N_ ("" ), +N_ ("enters batch mode that accepts commands" ), +PARSE_OPT_NOARG |PARSE_OPT_NONEG , + batch_option_callback),OPT_CMDMODE (0 ,"batch-all-objects" , &opt, N_("with --batch[-check]: ignores stdin, batches all known objects"), 'b'),/* Batch-specific options */ @@ -742,7 +842,7 @@ int cmd_cat_file(int argc, const char **argv, const char *prefix)/* Return early if we're in batch mode? */ if (batch.enabled) {if (opt_cw) - batch.cmdmode = opt; + batch.mode = opt;else if (opt && opt !='b' )usage_msg_optf (_ ("'-%c' is incompatible with batch mode" ), usage, options, opt);t/t1006-cat-file.sh +0
-0
t/t1006-cat-file.sh maybe_remove_timestamp () { · line 113
Quoted 2 lines
t/t1006-cat-file.sh +0
-0@@ -112,6 +112,46 @@ maybe_remove_timestamp () { fi }
It's really good that you've found a way to test fflush
Quoted 21 lines
t/t1006-cat-file.sh +21
-0+run_buffer_test () { + type=$1 + sha1=$2 + size=$3 + flush=$4 + + mkfifo V.input + exec 8<>V.input + rm V.input + + mkfifo V.output + exec 9<>V.output + rm V.output + + ( + git cat-file --buffer --batch-command <&8 >&9 & + echo $! >&9 && + wait $! + echo >&9 EARLY_EXIT + ) & + sh_pid=$!
t/t1006-cat-file.sh maybe_remove_timestamp () { · line 146
Quoted 10 lines
t/t1006-cat-file.sh +10
-0+ read fi_pid <&9 > + test_when_finished " + exec 8>&-; exec 9>&-; + kill $sh_pid && wait $sh_pid + kill $fi_pid && wait $fi_pid + true" + expect=$(echo "$sha1 $type $size") + echo "info $sha1" >&8 + if test "$flush" = "true" + then + echo "fflush" >&8
If I change "fflush" to "bad-command" then this test still passes. This is because die() flushes stdout and the read below will get the output it was expecting and not 'EARLY_EXIT'. I have a suggested change below to get around that also checks the exit code of "git cat-file" (This test effectively puts a git command upstream of a pipe which we try to avoid in order to pick up any crashes)
Quoted 12 lines
t/t1006-cat-file.sh +8
-0+ else + expect="EARLY_EXIT" + kill $fi_pid && wait $fi_pid + fi + read actual <&9 + test "$actual" = "$expect" +} + run_tests () { type=$1 sha1=$2
t/t1006-cat-file.sh $content" · line 218
Quoted 2 lines
t/t1006-cat-file.sh +0
-0@@ -177,6 +217,18 @@ $content" test_cmp expect actual '
Here is my suggestion based on your test - I ended up splitting the fflush and no-fflush cases
run_buffer_test_flush () {
type=$1
sha1=$2
size=$3
mkfifo input &&
test_when_finished 'rm input'
mkfifo output &&
exec 9<>output &&
test_when_finished 'rm output; exec 9<&-'
(
# TODO - Ideally we'd pipe the output of cat-file
# through "sed s'/$/\\/'" to make sure that that read
# would consume all the available
# output. Unfortunately we cannot do this as we cannot
# control when sed flushes its output. We could write
# a test helper in C that appended a '\' to the end of
# each line and flushes its output after every line.
git cat-file --buffer --batch-command <input 2>err &
echo $! &&
wait $!
echo $?
) >&9 &
sh_pid=$! &&
read cat_file_pid <&9 &&
test_when_finished "kill $cat_file_pid
kill $sh_pid; wait $sh_pid; :" &&
(
test_write_lines "info $sha1" fflush "info $sha1" &&
# TODO - consume all available input, not just one
# line (see above).
read actual <&9 &&
echo "$actual" >actual &&
echo "$sha1 $type $size" >expect &&
test_cmp expect actual
) >input &&
# check output is flushed on exit
read actual <&9 &&
echo "$actual" >actual &&
test_cmp expect actual &&
test_must_be_empty err &&
read status <&9 &&
test "$status" -eq 0
}run_buffer_test_no_flush () {
type=$1
sha1=$2
size=$3
mkfifo input &&
test_when_finished 'rm input'
mkfifo pid &&
exec 9<>pid &&
test_when_finished 'rm pid; exec 9<&-'
(
git cat-file --buffer --batch-command <input >output &
echo $! &&
wait $!
echo $?
) >&9 &
sh_pid=$! &&
read cat_file_pid <&9 &&
test_when_finished "kill $cat_file_pid
kill $sh_pid; wait $sh_pid; :" &&
(
test_write_lines "info $sha1" "info $sha1" &&
kill $cat_file_pid &&
read status <&9 &&
test "$status" -ne 0 &&
test_must_be_empty output
) >input
}Best Wishes
Phillip
Quoted 71 lines
t/t1006-cat-file.sh +43
-0+ test -z "$content" || + test_expect_success "--batch-command output of $type content is correct" ' + maybe_remove_timestamp "$batch_output" $no_ts >expect && + maybe_remove_timestamp "$(echo object $sha1 | git cat-file --batch-command)" $no_ts >actual && + test_cmp expect actual + ' + + test_expect_success "batch-command output of $type info is correct" ' + echo "$sha1 $type $size" >expect && + echo "info $sha1" | git cat-file --batch-command >actual && + test_cmp expect actual +' test_expect_success "custom --batch-check format" ' echo "$type $sha1" >expect && echo $sha1 | git cat-file --batch-check="%(objecttype) %(objectname)" >actual &&@@ -232,12 +284,29 @@ test_expect_success '--batch-check without %(rest) considers whole line' ' test_cmp expect actual ' +test_expect_success '--batch-command --buffer with flush is correct for blob' ' + run_buffer_test 'blob' $hello_sha1 $hello_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for blob' ' + run_buffer_test 'blob' $hello_sha1 $hello_size false +' + tree_sha1=$(git write-tree) + tree_size=$(($(test_oid rawsz) + 13)) tree_pretty_content="100644 blob $hello_sha1 hello" run_tests 'tree' $tree_sha1 $tree_size "" "$tree_pretty_content" +test_expect_success '--batch-command --buffer with flush is correct for tree' ' + run_buffer_test 'tree' $tree_sha1 $tree_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for tree' ' + run_buffer_test 'tree' $tree_sha1 $tree_size false +' + commit_message="Initial commit" commit_sha1=$(echo_without_newline "$commit_message" | git commit-tree $tree_sha1) commit_size=$(($(test_oid hexsz) + 137))@@ -263,6 +332,14 @@ tag_size=$(strlen "$tag_content") run_tests 'tag' $tag_sha1 $tag_size "$tag_content" "$tag_content" 1 +test_expect_success '--batch-command --buffer with flush is correct for tag' ' + run_buffer_test 'tag' $tag_sha1 $tag_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for tag' ' + run_buffer_test 'tag' $tag_sha1 $tag_size false +' + test_expect_success \ "Reach a blob from a tag pointing to it" \ "test '$hello_content' = \"\$(git cat-file blob $tag_sha1)\""@@ -964,4 +1041,10 @@ test_expect_success 'cat-file --batch-all-objects --batch-check ignores replace' test_cmp expect actual ' +test_expect_success 'batch-command unknown command' ' + echo unknown_command >cmd && + test_expect_code 128 git cat-file --batch-command < cmd 2>err && + grep -E "^fatal:.*unknown command.*" err +' + test_done
Quoted 2 lines · Christian Couder
Also I think at this point this should probably not be an RFC patch anymore but a regular one.
I think that this is due to my first "review" in [1], where I tried to get an understanding of what John's concrete usage plans were, since I couldn't figure out what they were on my own.
I'm not sure that I've seen a response along the lines of "we need to control when the output stream is flushed in order to do ..." yet, but I would be interested to see one before moving too much further ahead of where we already are.
(Apologies if such a response was written, and I missed it).
Thanks,
Taylor
Hi Taylor,
Quoted 4 lines · Taylor Blau
Quoted 2 lines · Christian Couder
Also I think at this point this should probably not be an RFC patch anymore but a regular one.
Quoted 8 lines
I think that this is due to my first "review" in [1], where I tried to get an understanding of what John's concrete usage plans were, since I couldn't figure out what they were on my own.
I'm not sure that I've seen a response along the lines of "we need to control when the output stream is flushed in order to do ..." yet, but I would be interested to see one before moving too much further ahead of where we already are.
This would be useful when there is another process A interacting with a long running git cat-file process B that is retrieving object information from the odb interactively but also wants to use --buffer mode.
In this scenario, if A is asked to retrieve a large list of object metadata, it wants to use --buffer mode to be more efficient but it would need a way to ensure that all of the contents have been flushed to the output. If we want to keep B running to save startup time (since otherwise we might need to spawn many git cat-file processes), then having a flush command where we can guarantee a flush would be very handy.
Quoted 2 lines
(Apologies if such a response was written, and I missed it).
Nope, don't think I explained the need for a flush command very clearly.
thanks
Quoted 5 lines
Thanks,
Taylor
Quoted 10 lines · John Cai
Quoted 4 lines · Taylor Blau
I'm not sure that I've seen a response along the lines of "we need to control when the output stream is flushed in order to do ..." yet, but I would be interested to see one before moving too much further ahead of where we already are.
This would be useful when there is another process A interacting with a long running git cat-file process B that is retrieving object information from the odb interactively but also wants to use --buffer mode.
Let me try and repeat my understanding of what you said to make sure that I fully grok the use-case you have in mind.
You have a repository and want to have a long-running git cat-file process that can serve multiple requests. Because the processes which interact with your long-running cat-file may ask for many objects, you don't want to flush the output buffer after each object, and so would ideally like to use --buffer.
But that doesn't quite work, since the cat-file process may not have decided to flush its output buffer even when process A is about to go away.
I wonder about the viability of accomplishing this via a signal handler, i.e., that cat-file would call fflush(2) whenever it receives e.g., SIGUSR1. A couple of possible downsides:
- SIGUSR1 doesn't exist on Windows AFAIK.
- There are definitely going to be synchrony issues to contend with. What happens if we receive our signal while writing to the output stream? I think you would just need to mark a variable that indicates we should flush after finishing serving the current request, but I haven't thought too hard about it.
So maybe a signal isn't the way to go. But I don't think --stdin-cmd is the simplest approach either. At the very least, I don't totally understand your plan after implementing a flush command. You mention that it would be nice to implement other commands, but I'm not totally convinced by your examples[1].
I wonder if we could strike a middle ground, which might look like git cat-file --batch --buffer, and just feeding it something which we know for certain isn't an object identifier. In other words, what if we did something as simple as:
--- >8 ---
builtin/cat-file.c +5 -0
@@ -595,6 +595,11 @@ static int batch_objects(struct batch_options *opt) warn_on_object_refname_ambiguity =0 ;while (strbuf_getline (&input, stdin) !=EOF ) { +if (!strcmp ("<flush>" , input.buf)) { +fflush (stdout); +continue ; + } +if (data.split_on_whitespace) {/* * Split at first whitespace, tying off the beginning
--- 8< ---
On the other hand, something even hackier than the above is that we flush stdout whenever we get a request to print an object which could not be found. So if you feed a single "\n" to your cat-file process, you'll get " missing" on its output, and the buffer will immediately be flushed.
I'm not sure that I'd recommend relying on that behavior exactly, but if you're looking for a short-term solution, it might work ;).
Thanks,
Taylor
[1]: One that comes to mind is changing the output format mid-stream.
But how often does it really make sense to change the output format? I can understand wanting to flush at the end asking cat-file for a bunch of objects, but I don't see how you would want to change the output format often enough that shaving off Git's negligible startup cost is worthwhile (or couldn't be accomplished by just spawning another cat-file process and using that).
Quoted 10 lines · John Cai
Quoted 5 lines
So maybe a signal isn't the way to go. But I don't think
--stdin-cmdis the simplest approach either. At the very least, I don't totally understand your plan after implementing a flush command. You mention that it would be nice to implement other commands, but I'm not totally convinced by your examples[1].I agree that if flush were the only use case for a new flag, it might not be worth it. But, the flush command is only one of the use cases that a --stdin-cmd (now changed to --batch-command per Phillip's suggestion)
Quoted 8 lines
There are two other commands in this RFC
object <rev>
info <rev>These are described in [1] that are also a motivation for a command interface.
The description in [1] explains why a command interface would be necessary.
This seems like a more realistic and well-motivated proposal, IMHO. I am a little curious that having the ability to switch between asking for an object's contents and its metadata would lead to saving thousands of processes per server.
(Apropos of this series, I am curious: how long does GitLab keep a pair of cat-file programs running for each repository?)
In any case, I'll take a closer look over the aforementioned version and let you know what my thoughts are, probably tomorrow.
Quoted 1 line
Thanks,
Taylor
Hi Christian
Quoted 146 lines · Christian Couder
Quoted 3 lines · John Cai
This RFC patch proposes a new flag --batch-command that works with git-cat-file --batch.
The subject is "Re: [RFC v3] cat-file: add a --stdin-cmd mode" and now you are talking about '--batch-command' instead of '--stdin-cmd'.
"that works with git-cat-file --batch" is not very clear. Maybe you could find a wording that explains better how --batch-command is different from --batch.
Also I think at this point this should probably not be an RFC patch anymore but a regular one.
Quoted 6 lines
Similar to git-update-ref --stdin, it will accept
commands and arguments from stdin.The start of this idea was discussed in [1], where the original motivation was to be able to control when the buffer was flushed to stdout in --buffer mode.
That would be nice in a cover letter but I am not sure a commit message is the right place for this.
Quoted 6 lines
However, this can actually be much more useful in situations when git-cat-file --batch is being used as a long lived backend query process. At GitLab, we use a pair of cat-file processes. One for iterating over object metadata with --batch-check, and the other to grab object contents with --batch. However, if we had --batch-command, we could get rid of the second --batch-check process,
Maybe s/second// would make it clear that there are no two --batch-command processes.
Quoted 4 lines
and just have one process
where we can flip between getting object info, and getting object contents. This can lead to huge savings since on a given server there could be hundreds to thousands of git cat-file processes at a time.It's not clear if all the git cat-file processes you are talking about are mostly --batch-check processes or --batch processes, or a roughly equal amount of both. My guess is the latter and that --batch-command would mean that there would be around two times fewer cat-file processes.
Quoted 3 lines
git cat-file --batch-command
$ <command> [arg1] [arg2] NLIt's a bit unclear what the 2 above lines mean. Maybe you could add a small explanation like for example "The new flag can be used like this:" and "It receives commands from stdin in the format:"
Also not sure why there is a '$' char in front of '<command> [arg1] [arg2] NL' but not in front of 'git cat-file --batch-command'. It doesn't look like in the 'git update-ref --stdin' doc that '$' are used in front of the commands that can be passed through stdin.
Quoted 1 line
This patch adds three commands: object, info, fflush
Maybe s/three commands/the following first three commands/
Quoted 3 lines
$ object <sha1> NL $ info <sha1> NL $ fflush NLIdem about '$'.
Quoted 2 lines
These three would be immediately useful in GitLab's context, but one can imagine this mode to be further extended for other things.
Not very clear which "mode" you are talking about. You have been talking about a mode only in the subject so far. Maybe you should talk a bit about that above when '<command> [arg1] [arg2] NL' is introduced.
Also you don't talk about the output format. --batch and --batch-check accept [=<format>], but it looks like --batch-command doesn't.
Quoted 5 lines
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.In a cover letter that would be ok, but I am not sure that a commit message is the best place for this kind of details about future work.
Quoted 40 lines
This would be the first step in adding such an interface to git-cat-file.
[1] https://lore.kernel.org/git/[email protected]/
Signed-off-by John Cai <[email protected]>---
Taylor, I'd be interested in your thoughts on this proposal since you helped review the previous patch that turned into this RFC. Thanks!
Changes from v2:
- refactored tests to be within
run_tests()
- added a test to test --buffer behavior with fflush
- cleaned upcat-file.c: clarified var names, removed unnecessary code based on suggestions from Phillip Wood
- removed strvec changesChanges from v1:
- changed option name to batch-command.
- changed command function interface to receive the whole line after the command name to put the onus of parsing arguments to each individual command function.
- pass in whole line tobatch_one_objectin bothparse_cmd_objectandparse_cmd_infoto support spaces in the object reference.
- removed addition of -z to include in a separate patch series
- added documentation.--- Documentation/git-cat-file.txt | 15 +++++ builtin/cat-file.c | 114 +++++++++++++++++++++++++++++++-- t/t1006-cat-file.sh | 83 ++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 7 deletions(-)Documentation/git-cat-file.txt +0
-0Documentation/git-cat-file.txt OPTIONS · line 100
Quoted 5 lines
Documentation/git-cat-file.txt +2
-0@@ -96,6 +96,21 @@ OPTIONS need to specify the path, separated by whitespace. See the section `BATCH OUTPUT` below for details. +--batch-command:: + Enter a command mode that reads from stdin.Maybe s/a command mode that reads from stdin/a mode that reads commands from stdin/
Also I would expect something about the output, like perhaps "...and ouputs the command results to stdout".
Documentation/git-cat-file.txt OPTIONS · line 103
Quoted 4 lines
May not be combined with any
Documentation/git-cat-file.txt +3
-0+ other options or arguments except `--textconv` or `--filters`, in which + case the input lines also need to specify the path, separated by + whitespace. See the section `BATCH OUTPUT` below for details.
Quoted 4 lines
The BATCH OUTPUT section says that a format can be passed but that doesn't seem to be the case with --batch-command. So you might need to make some changes to that section too or add a bit more details about the output here.
Thinking about this more, I wonder if it'd be worth it to allow the --batch-command=<format> for backwards compatibility reasons for users who switch over to using --batch-command from --batch and --batch-check.
The only thing that makes me hesitant is that the <format> would only be relevant to the "info" and "object" commands instead of being relevant to all commands in --batch-command mode.
Quoted 123 lines
Quoted 18 lines
Documentation/git-cat-file.txt +9
-0+object <object>:: + Print object contents for object reference <object> + +info <object>:: + Print object info for object reference <object> + +flush:: + Flush to stdout immediately when used with --buffer + --batch-all-objects:: Instead of reading a list of objects on stdin, perform the requested batch operation on all objects in the repository andbuiltin/cat-file.c +0
-0builtin/cat-file.c struct batch_options { · line 30
Quoted 8 lines
builtin/cat-file.c +2
-1@@ -24,9 +24,11 @@ struct batch_options {int buffer_output;int all_objects;int unordered; -int cmdmode;/* may be 'w' or 'c' for --filters or --textconv */ +int mode;/* may be 'w' or 'c' for --filters or --textconv */ const char *format; +int command; };Maybe add a blank line here.
builtin/cat-file.c static void print_object_or_die(struct batch_options *opt, struct expand_data *d · line 307
Quoted 10 lines
builtin/cat-file.c +2
-1+static char line_termination ='\n' ;static const char *force_path;@@ -302,19 +304,19 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *dif (data->type ==OBJ_BLOB ) {if (opt->buffer_output)fflush (stdout); -if (opt->cmdmode) { +if (opt->mode) {The mechanical s/cmdmode/mode/g change could have been made in a preparatory patch to make this patch a bit smaller and easier to digest.
Quoted 26 lines
builtin/cat-file.c +26
-0+static void batch_objects_command (struct batch_options *opt, +struct strbuf *output, +struct expand_data *data) +{ +struct strbuf input =STRBUF_INIT ; + +/* Read each line dispatch its command */ +while (!strbuf_getwholeline (&input, stdin, line_termination)) { +int i; +const struct parse_cmd *cmd =NULL ; +const char *p, *cmd_end; + +if (*input.buf == line_termination) +die ("empty command in input" ); +else if (isspace (*input.buf)) +die ("whitespace before command: %s" , input.buf); + +for (i =0 ; i <ARRAY_SIZE (commands); i++) { +const char *prefix = commands[i].prefix; +char c; +if (!skip_prefix (input.buf, prefix, &cmd_end)) +continue ; +/* +* If the command has arguments, verify that it's +* followed by a space. Otherwise, it shall be followed +* by a line terminator. builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 587
Quoted 10 lines
builtin/cat-file.c +10
-0+*/ + c = commands[i].takes_args ?' ' : line_termination; +if (input.buf[strlen (prefix)] != c) +die ("arguments invalid for command: %s" , commands[i].prefix); + + cmd = &commands[i]; +if (cmd->takes_args) { + p = cmd_end +1 ; +// strip newline before handing it to the +// handling function So above the /* */ comments delimiters are used but here // is used. I am not sure we support // these days, but if we do, I think it would be better to avoid mixing comment styles in the same function.
Quoted 15 lines
builtin/cat-file.c +13
-0+ input.buf[strcspn (input.buf,"\n" )] ='\0' ; + } + +break ; + } + +if (!cmd) +die ("unknown command: %s" , input.buf); + + cmd->fn (opt, p, output, data); + } +strbuf_release (&input); +}builtin/cat-file.c static int batch_objects(struct batch_options *opt) · line 688
Quoted 7 lines
builtin/cat-file.c +3
-0@@ -590,6 +682,9 @@ static int batch_objects(struct batch_options *opt) save_warning = warn_on_object_refname_ambiguity; warn_on_object_refname_ambiguity =0 ; +if (command) +batch_objects_command (opt, &output, &data); +while (strbuf_getline (&input, stdin) !=EOF ) {I think
batch_objects_command()will consume everything from stdin, so it doesn't make sense to try to read again from stdin after it. Maybe the whole while (...) { ... } clause should be inside an else clause or something.Quoted 10 lines
builtin/cat-file.c +1
-0if (data.split_on_whitespace) {/* @@ -636,6 +731,7 @@ static int batch_option_callback(const struct option *opt, bo->enabled =1 ; bo->print_contents = !strcmp (opt->long_name,"batch" ); + bo->command = !strcmp (opt->long_name,"batch-command" ); bo->format = arg;return 0 ;
Hi Phillip
Quoted 91 lines · Phillip Wood
Hi John
Quoted 22 lines · John Cai
This RFC patch proposes a new flag --batch-command that works with git-cat-file --batch. Similar to git-update-ref --stdin, it will accept commands and arguments from stdin.
The start of this idea was discussed in [1], where the original motivation was to be able to control when the buffer was flushed to stdout in --buffer mode.
However, this can actually be much more useful in situations when git-cat-file --batch is being used as a long lived backend query process. At GitLab, we use a pair of cat-file processes. One for iterating over object metadata with --batch-check, and the other to grab object contents with --batch. However, if we had --batch-command, we could get rid of the second --batch-check process, and just have one process where we can flip between getting object info, and getting object contents. This can lead to huge savings since on a given server there could be hundreds to thousands of git cat-file processes at a time.
git cat-file --batch-command
$ <command> [arg1] [arg2] NLQuoted 8 lines
This patch adds three commands: object, info, fflush
$ object <sha1> NL $ info <sha1> NL $ fflush NLThese three would be immediately useful in GitLab's context, but one can imagine this mode to be further extended for other things.
I think this is moving in the right direction, I've left some comments below.
Quoted 55 lines
Future improvements:
- a non-trivial part of "cat-file --batch" time is spent on parsing its argument and seeing if it's a revision, ref etc. So we could add a command that only accepts a full-length 40 character SHA-1.This would be the first step in adding such an interface to git-cat-file.
[1] https://lore.kernel.org/git/[email protected]/
Signed-off-by John Cai <[email protected]>---
Taylor, I'd be interested in your thoughts on this proposal since you helped review the previous patch that turned into this RFC. Thanks!
Changes from v2:
- refactored tests to be within
run_tests()
- added a test to test --buffer behavior with fflush
- cleaned upcat-file.c: clarified var names, removed unnecessary code based on suggestions from Phillip Wood
- removed strvec changesChanges from v1:
- changed option name to batch-command.
- changed command function interface to receive the whole line after the command name to put the onus of parsing arguments to each individual command function.
- pass in whole line tobatch_one_objectin bothparse_cmd_objectandparse_cmd_infoto support spaces in the object reference.
- removed addition of -z to include in a separate patch series
- added documentation.--- Documentation/git-cat-file.txt | 15 +++++ builtin/cat-file.c | 114 +++++++++++++++++++++++++++++++-- t/t1006-cat-file.sh | 83 ++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 7 deletions(-)Documentation/git-cat-file.txt +6
-0@@ -96,6 +96,21 @@ OPTIONS need to specify the path, separated by whitespace. See the section `BATCH OUTPUT` below for details. +--batch-command:: + Enter a command mode that reads from stdin. May not be combined with any + other options or arguments except `--textconv` or `--filters`, in which + case the input lines also need to specify the path, separated by + whitespace. See the section `BATCH OUTPUT` below for details. + +object <object>::
Quoted 8 lines
Documentation/git-cat-file.txt OPTIONS · line 111
Quoted 6 lines
Documentation/git-cat-file.txt +6
-0+ Print object contents for object reference <object> + +info <object>:: + Print object info for object reference <object> + +flush::I think this is a better name than fflush as calling fflush is just an implementation detail. I've been thinking about this and have some concerns with the current implementation as it allows the caller to force a flush but the output may be flushed at other times and so it does not allow for deadlock free reading and writing to cat-file from a single process. If instead we buffered the input lines and only processed then when we received a flush command it would be easy to read and write to cat-file from a single process without deadlocks. This would mean that callers would have to add flush commands to get any output before they closed the pipe writing to cat-file.
To address this concern, I wonder if instead of a flush command what we could do is to have --batch-command support "read transactions" similar to update-ref. eg:
git cat-file --batch-command
begin info
<sha1>
<sha1>
<sha1>
<sha1>
commit
We could queue up these references, and then get them all once "commit" is entered and call fflush().
Quoted 425 lines
Quoted 11 lines
Documentation/git-cat-file.txt +2
-0+ Flush to stdout immediately when used with --buffer + --batch-all-objects:: Instead of reading a list of objects on stdin, perform the requested batch operation on all objects in the repository andbuiltin/cat-file.c +0
-0builtin/cat-file.c struct batch_options { · line 27
Quoted 5 lines
builtin/cat-file.c +1
-1@@ -24,9 +24,11 @@ struct batch_options {int buffer_output;int all_objects;int unordered; -int cmdmode;/* may be 'w' or 'c' for --filters or --textconv */ +int mode;/* may be 'w' or 'c' for --filters or --textconv */ If you really need to rename this variable then doing that in a separate preparatory patch would make this easier to review as it separates out two separate sets of changes.
builtin/cat-file.c struct batch_options { · line 29
Quoted 2 lines
builtin/cat-file.c +1
-0const char *format; +int command;Can't we just call this
batch_commandand leave cmdmode alone? I don't know maybe cmdmode would be confused with having something to do withbatch_commandthen.builtin/cat-file.c struct batch_options { · line 31
Quoted 2 lines
builtin/cat-file.c +1
-0}; +static char line_termination ='\n' ;This seems unnecessary as it is the only permitted line ending
Quoted 92 lines
builtin/cat-file.c +0
-0static const char *force_path; @@ -302,19 +304,19 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *d if (data->type == OBJ_BLOB) {if (opt->buffer_output) fflush(stdout);builtin/cat-file.c +61
-3- if (opt->cmdmode) { + if (opt->mode) { char *contents; unsigned long size; if (!data->rest) die("missing path for '%s'", oid_to_hex(oid)); - if (opt->cmdmode == 'w') { + if (opt->mode == 'w') { if (filter_object(data->rest, 0100644, oid, &contents, &size)) die("could not convert '%s' %s", oid_to_hex(oid), data->rest); - } else if (opt->cmdmode == 'c') { + } else if (opt->mode == 'c') { enum object_type type; if (!textconv_object(the_repository, data->rest, 0100644, oid,@@ -326,7 +328,7 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *ddie ("could not convert '%s' %s" ,oid_to_hex (oid), data->rest); }else -BUG ("invalid cmdmode: %c" , opt->cmdmode); +BUG ("invalid mode: %c" , opt->mode);batch_write (opt, contents, size);free (contents); }else {@@ -508,6 +510,95 @@ static int batch_unordered_packed(const struct object_id *oid, data); } +static void parse_cmd_object(struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ + opt->print_contents =1 ; +batch_one_object (line, output, opt, data); +} + +static void parse_cmd_info (struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ + opt->print_contents =0 ; +batch_one_object (line, output, opt, data); +} + +static void parse_cmd_fflush (struct batch_options *opt, +const char *line, +struct strbuf *output, +struct expand_data *data) +{ +fflush (stdout); +} + +typedef void (*parse_cmd_fn_t )(struct batch_options *,const char *, +struct strbuf *,struct expand_data *); + +static const struct parse_cmd { +const char *prefix; +parse_cmd_fn_t fn; +unsigned takes_args; +} commands[] = { + {"object" , parse_cmd_object,1 }, + {"info" , parse_cmd_info,1 }, + {"fflush" , parse_cmd_fflush,0 }, +}; + +static void batch_objects_command (struct batch_options *opt, +struct strbuf *output, +struct expand_data *data) +{ +struct strbuf input =STRBUF_INIT ; + +/* Read each line dispatch its command */ +while (!strbuf_getwholeline (&input, stdin, line_termination)) { +int i; +const struct parse_cmd *cmd =NULL ; +const char *p, *cmd_end; + +if (*input.buf == line_termination) +die ("empty command in input" ); +else if (isspace (*input.buf)) +die ("whitespace before command: %s" , input.buf); + +for (i =0 ; i <ARRAY_SIZE (commands); i++) { +const char *prefix = commands[i].prefix;builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 579
Quoted 10 lines
builtin/cat-file.c +10
-0+char c; +if (!skip_prefix (input.buf, prefix, &cmd_end)) +continue ; +/* +* If the command has arguments, verify that it's +* followed by a space. Otherwise, it shall be followed +* by a line terminator. +*/ + c = commands[i].takes_args ?' ' : line_termination; +if (input.buf[strlen (prefix)] != c)As I pointed out in the last round you can use
cmd_endhere rather than calling strlen. I've just noticed that this will fail for a command that does not take arguments when the last input line does not end with '\n'. I thinkif (*cmd_end && *cmd_end != c)would be safer
builtin/cat-file.c static int batch_unordered_packed(const struct object_id *oid, · line 588
Quoted 8 lines
builtin/cat-file.c +8
-0+die ("arguments invalid for command: %s" , commands[i].prefix); + + cmd = &commands[i]; +if (cmd->takes_args) { + p = cmd_end +1 ; +// strip newline before handing it to the +// handling function + input.buf[strcspn (input.buf,"\n" )] ='\0' ;When I suggested replacing
strstr()last time I failed to notice that we know that if there is a newline character it is at input.buf[len - 1] so we don't need to scan the whole string to find it.if (input.buf[input.len - 1] == '\n') input.buf[--buf.len] = '\0';(feel free to change it to avoid the prefix operator)
Quoted 32 lines
builtin/cat-file.c +15
-1+ } + +break ; + } + +if (!cmd) +die ("unknown command: %s" , input.buf); + + cmd->fn (opt, p, output, data); + } +strbuf_release (&input); +} +static int batch_objects (struct batch_options *opt) {struct strbuf input =STRBUF_INIT ;@@ -515,6 +606,7 @@ static int batch_objects(struct batch_options *opt)struct expand_data data;int save_warning;int retval =0 ; +const int command = opt->command;if (!opt->format) opt->format ="%(objectname) %(objecttype) %(objectsize)" ;@@ -529,7 +621,7 @@ static int batch_objects(struct batch_options *opt)strbuf_expand (&output, opt->format, expand_format, &data); data.mark_query =0 ;strbuf_release (&output); -if (opt->cmdmode) +if (opt->mode) data.split_on_whitespace =1 ;/* builtin/cat-file.c static int batch_objects(struct batch_options *opt) · line 686
Quoted 5 lines
builtin/cat-file.c +2
-0@@ -590,6 +682,9 @@ static int batch_objects(struct batch_options *opt) save_warning = warn_on_object_refname_ambiguity; warn_on_object_refname_ambiguity =0 ; + if (command) +batch_objects_command (opt, &output, &data); +Moving this is good as we no longer need to touch the line below
Quoted 34 lines
builtin/cat-file.c +6
-1while (strbuf_getline (&input, stdin) !=EOF ) {if (data.split_on_whitespace) {/* @@ -636,6 +731,7 @@ static int batch_option_callback(const struct option *opt, bo->enabled =1 ; bo->print_contents = !strcmp (opt->long_name,"batch" ); + bo->command = !strcmp (opt->long_name,"batch-command" ); bo->format = arg;return 0 ;@@ -683,6 +779,10 @@ int cmd_cat_file(int argc, const char **argv, const char *prefix) N_("like --batch, but don't emit <contents>"), PARSE_OPT_OPTARG | PARSE_OPT_NONEG, batch_option_callback), +OPT_CALLBACK_F (0 ,"batch-command" , &batch,N_ ("" ), +N_ ("enters batch mode that accepts commands" ), +PARSE_OPT_NOARG |PARSE_OPT_NONEG , + batch_option_callback),OPT_CMDMODE (0 ,"batch-all-objects" , &opt, N_("with --batch[-check]: ignores stdin, batches all known objects"), 'b'),/* Batch-specific options */ @@ -742,7 +842,7 @@ int cmd_cat_file(int argc, const char **argv, const char *prefix)/* Return early if we're in batch mode? */ if (batch.enabled) {if (opt_cw) - batch.cmdmode = opt; + batch.mode = opt;else if (opt && opt !='b' )usage_msg_optf (_ ("'-%c' is incompatible with batch mode" ), usage, options, opt);t/t1006-cat-file.sh +0
-0t/t1006-cat-file.sh maybe_remove_timestamp () { · line 113
Quoted 2 lines
t/t1006-cat-file.sh +0
-0@@ -112,6 +112,46 @@ maybe_remove_timestamp () { fi }It's really good that you've found a way to test fflush
Quoted 21 lines
t/t1006-cat-file.sh +21
-0+run_buffer_test () { + type=$1 + sha1=$2 + size=$3 + flush=$4 + + mkfifo V.input + exec 8<>V.input + rm V.input + + mkfifo V.output + exec 9<>V.output + rm V.output + + ( + git cat-file --buffer --batch-command <&8 >&9 & + echo $! >&9 && + wait $! + echo >&9 EARLY_EXIT + ) & + sh_pid=$!t/t1006-cat-file.sh maybe_remove_timestamp () { · line 146
Quoted 10 lines
t/t1006-cat-file.sh +10
-0+ read fi_pid <&9 > + test_when_finished " + exec 8>&-; exec 9>&-; + kill $sh_pid && wait $sh_pid + kill $fi_pid && wait $fi_pid + true" + expect=$(echo "$sha1 $type $size") + echo "info $sha1" >&8 + if test "$flush" = "true" + then + echo "fflush" >&8If I change "fflush" to "bad-command" then this test still passes. This is because
die()flushes stdout and the read below will get the output it was expecting and not 'EARLY_EXIT'. I have a suggested change below to get around that also checks the exit code of "git cat-file" (This test effectively puts a git command upstream of a pipe which we try to avoid in order to pick up any crashes)Quoted 12 lines
t/t1006-cat-file.sh +8
-0+ else + expect="EARLY_EXIT" + kill $fi_pid && wait $fi_pid + fi + read actual <&9 + test "$actual" = "$expect" +} + run_tests () { type=$1 sha1=$2t/t1006-cat-file.sh $content" · line 218
Quoted 2 lines
t/t1006-cat-file.sh +0
-0@@ -177,6 +217,18 @@ $content" test_cmp expect actual 'Here is my suggestion based on your test - I ended up splitting the fflush and no-fflush cases
run_buffer_test_flush () { type=$1 sha1=$2 size=$3 mkfifo input && test_when_finished 'rm input' mkfifo output && exec 9<>output && test_when_finished 'rm output; exec 9<&-' ( # TODO - Ideally we'd pipe the output of cat-file # through "sed s'/$/\\/'" to make sure that that read # would consume all the available # output. Unfortunately we cannot do this as we cannot # control when sed flushes its output. We could write # a test helper in C that appended a '\' to the end of # each line and flushes its output after every line. git cat-file --buffer --batch-command <input 2>err & echo $! && wait $! echo $? ) >&9 & sh_pid=$! && read cat_file_pid <&9 && test_when_finished "kill $cat_file_pid kill $sh_pid; wait $sh_pid; :" && ( test_write_lines "info $sha1" fflush "info $sha1" && # TODO - consume all available input, not just one # line (see above). read actual <&9 && echo "$actual" >actual && echo "$sha1 $type $size" >expect && test_cmp expect actual ) >input && # check output is flushed on exit read actual <&9 && echo "$actual" >actual && test_cmp expect actual && test_must_be_empty err && read status <&9 && test "$status" -eq 0 }run_buffer_test_no_flush () { type=$1 sha1=$2 size=$3 mkfifo input && test_when_finished 'rm input' mkfifo pid && exec 9<>pid && test_when_finished 'rm pid; exec 9<&-' ( git cat-file --buffer --batch-command <input >output & echo $! && wait $! echo $? ) >&9 & sh_pid=$! && read cat_file_pid <&9 && test_when_finished "kill $cat_file_pid kill $sh_pid; wait $sh_pid; :" && ( test_write_lines "info $sha1" "info $sha1" && kill $cat_file_pid && read status <&9 && test "$status" -ne 0 && test_must_be_empty output ) >input }Best Wishes
Phillip
Quoted 65 lines
t/t1006-cat-file.sh +39
-0+ test -z "$content" || + test_expect_success "--batch-command output of $type content is correct" ' + maybe_remove_timestamp "$batch_output" $no_ts >expect && + maybe_remove_timestamp "$(echo object $sha1 | git cat-file --batch-command)" $no_ts >actual && + test_cmp expect actual + ' + + test_expect_success "batch-command output of $type info is correct" ' + echo "$sha1 $type $size" >expect && + echo "info $sha1" | git cat-file --batch-command >actual && + test_cmp expect actual +' test_expect_success "custom --batch-check format" ' echo "$type $sha1" >expect && echo $sha1 | git cat-file --batch-check="%(objecttype) %(objectname)" >actual &&@@ -232,12 +284,29 @@ test_expect_success '--batch-check without %(rest) considers whole line' ' test_cmp expect actual ' +test_expect_success '--batch-command --buffer with flush is correct for blob' ' + run_buffer_test 'blob' $hello_sha1 $hello_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for blob' ' + run_buffer_test 'blob' $hello_sha1 $hello_size false +' + tree_sha1=$(git write-tree) + tree_size=$(($(test_oid rawsz) + 13)) tree_pretty_content="100644 blob $hello_sha1 hello" run_tests 'tree' $tree_sha1 $tree_size "" "$tree_pretty_content" +test_expect_success '--batch-command --buffer with flush is correct for tree' ' + run_buffer_test 'tree' $tree_sha1 $tree_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for tree' ' + run_buffer_test 'tree' $tree_sha1 $tree_size false +' + commit_message="Initial commit" commit_sha1=$(echo_without_newline "$commit_message" | git commit-tree $tree_sha1) commit_size=$(($(test_oid hexsz) + 137))@@ -263,6 +332,14 @@ tag_size=$(strlen "$tag_content") run_tests 'tag' $tag_sha1 $tag_size "$tag_content" "$tag_content" 1 +test_expect_success '--batch-command --buffer with flush is correct for tag' ' + run_buffer_test 'tag' $tag_sha1 $tag_size true +' + +test_expect_success '--batch-command --buffer without flush is correct for tag' ' + run_buffer_test 'tag' $tag_sha1 $tag_size false +' + test_expect_success \ "Reach a blob from a tag pointing to it" \ "test '$hello_content' = \"\$(git cat-file blob $tag_sha1)\""@@ -964,4 +1041,10 @@ test_expect_success 'cat-file --batch-all-objects --batch-check ignores replace' test_cmp expect actual ' +test_expect_success 'batch-command unknown command' ' + echo unknown_command >cmd && + test_expect_code 128 git cat-file --batch-command < cmd 2>err && + grep -E "^fatal:.*unknown command.*" err +' + test_done