development/git
development/git
1
0
Fork 0
mirror of https://github.com/git/git synced 2024-10-06 00:29:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

update-ref: read commands in a line-wise fashion

Browse source 
The git-update-ref(1) supports a `--stdin` mode that allows it to read
all reference updates from standard input. This is mainly used to allow
for atomic reference updates that are all or nothing, so that either all
references will get updated or none.

Currently, git-update-ref(1) reads all commands as a single block of up
to 1000 characters and only starts processing after stdin gets closed.
This is less flexible than one might wish for, as it doesn't really
allow for longer-lived transactions and doesn't allow any verification
without committing everything. E.g. one may imagine the following
exchange:

    > start
    < start: ok
    > update refs/heads/master $NEWOID1 $OLDOID1
    > update refs/heads/branch $NEWOID2 $OLDOID2
    > prepare
    < prepare: ok
    > commit
    < commit: ok

When reading all input as a whole block, the above interactive protocol
is obviously impossible to achieve. But by converting the command to
read commands linewise, we can make it more interactive than before.

Obviously, the linewise interface is only a first step in making
git-update-ref(1) work in a more transaction-oriented way. Missing is
most importantly support for transactional commands that manage the
current transaction.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Patrick Steinhardt 2020-04-02 09:09:57 +02:00 committed by Junio C Hamano
parent de0e0d650a
commit 94fd491a54
1 changed files with 45 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
builtin/update-ref.c
View file

@ -178,8 +178,8 @@ static int parse_next_oid(const char **next, const char *end,
* depending on how line_termination is set.
*/
static const char *parse_cmd_update(struct ref_transaction *transaction,
const char *next, const char *end)
static void parse_cmd_update(struct ref_transaction *transaction,
const char *next, const char *end)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@ -209,12 +209,10 @@ static const char *parse_cmd_update(struct ref_transaction *transaction,
update_flags = default_flags;
free(refname);
strbuf_release(&err);
return next;
}
static const char *parse_cmd_create(struct ref_transaction *transaction,
const char *next, const char *end)
static void parse_cmd_create(struct ref_transaction *transaction,
const char *next, const char *end)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@ -241,12 +239,10 @@ static const char *parse_cmd_create(struct ref_transaction *transaction,
update_flags = default_flags;
free(refname);
strbuf_release(&err);
return next;
}
static const char *parse_cmd_delete(struct ref_transaction *transaction,
const char *next, const char *end)
static void parse_cmd_delete(struct ref_transaction *transaction,
const char *next, const char *end)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@ -277,12 +273,10 @@ static const char *parse_cmd_delete(struct ref_transaction *transaction,
update_flags = default_flags;
free(refname);
strbuf_release(&err);
return next;
}
static const char *parse_cmd_verify(struct ref_transaction *transaction,
const char *next, const char *end)
static void parse_cmd_verify(struct ref_transaction *transaction,
const char *next, const char *end)
{
struct strbuf err = STRBUF_INIT;
char *refname;
@ -306,71 +300,82 @@ static const char *parse_cmd_verify(struct ref_transaction *transaction,
update_flags = default_flags;
free(refname);
strbuf_release(&err);
return next;
}
static const char *parse_cmd_option(struct ref_transaction *transaction,
const char *next, const char *end)
static void parse_cmd_option(struct ref_transaction *transaction,
const char *next, const char *end)
{
const char *rest;
if (skip_prefix(next, "no-deref", &rest) && *rest == line_termination)
update_flags |= REF_NO_DEREF;
else
die("option unknown: %s", next);
return rest;
}
static const struct parse_cmd {
const char *prefix;
const char *(*fn)(struct ref_transaction *, const char *, const char *);
void (*fn)(struct ref_transaction *, const char *, const char *);
unsigned args;
} command[] = {
{ "update", parse_cmd_update },
{ "create", parse_cmd_create },
{ "delete", parse_cmd_delete },
{ "verify", parse_cmd_verify },
{ "option", parse_cmd_option },
{ "update", parse_cmd_update, 3 },
{ "create", parse_cmd_create, 2 },
{ "delete", parse_cmd_delete, 2 },
{ "verify", parse_cmd_verify, 2 },
{ "option", parse_cmd_option, 1 },
};
static void update_refs_stdin(void)
{
struct strbuf input = STRBUF_INIT, err = STRBUF_INIT;
struct ref_transaction *transaction;
const char *next;
int i;
if (strbuf_read(&input, 0, 1000) < 0)
die_errno("could not read from stdin");
next = input.buf;
int i, j;
transaction = ref_transaction_begin(&err);
if (!transaction)
die("%s", err.buf);
/* Read each line dispatch its command */
while (next < input.buf + input.len) {
while (!strbuf_getwholeline(&input, stdin, line_termination)) {
const struct parse_cmd *cmd = NULL;
if (*next == line_termination)
if (*input.buf == line_termination)
die("empty command in input");
else if (isspace(*next))
die("whitespace before command: %s", next);
else if (isspace(*input.buf))
die("whitespace before command: %s", input.buf);
for (i = 0; i < ARRAY_SIZE(command); i++) {
const char *prefix = command[i].prefix;
char c;
if (!skip_prefix(next, prefix, &next) ||
!skip_prefix(next, " ", &next))
if (!starts_with(input.buf, prefix))
continue;
/*
* If the command has arguments, verify that it's
* followed by a space. Otherwise, it shall be followed
* by a line terminator.
*/
c = command[i].args ? ' ' : line_termination;
if (input.buf[strlen(prefix)] != c)
continue;
cmd = &command[i];
break;
}
if (!cmd)
die("unknown command: %s", next);
die("unknown command: %s", input.buf);
next = cmd->fn(transaction, next, input.buf + input.len);
next++;
/*
* Read additional arguments if NUL-terminated. Do not raise an
* error in case there is an early EOF to let the command
* handle missing arguments with a proper error message.
*/
for (j = 1; line_termination == '\0' && j < cmd->args; j++)
if (strbuf_appendwholeline(&input, stdin, line_termination))
break;
cmd->fn(transaction, input.buf + strlen(cmd->prefix) + !!cmd->args,
input.buf + input.len);
}
if (ref_transaction_commit(transaction, &err))