2005-04-09 16:53:05 +00:00
|
|
|
/*
|
|
|
|
|
* Check-out files from the "current cache directory"
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2005 Linus Torvalds
|
|
|
|
|
*
|
|
|
|
|
*/
|
2022-11-19 13:07:38 +00:00
|
|
|
#define USE_THE_INDEX_VARIABLE
|
2007-07-14 23:14:45 +00:00
|
|
|
#include "builtin.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2023-03-21 06:25:54 +00:00
|
|
|
#include "gettext.h"
|
2014-10-01 10:28:42 +00:00
|
|
|
#include "lockfile.h"
|
2006-03-01 02:43:33 +00:00
|
|
|
#include "quote.h"
|
2023-04-22 20:17:20 +00:00
|
|
|
#include "repository.h"
|
2006-04-25 04:18:58 +00:00
|
|
|
#include "cache-tree.h"
|
2008-10-18 01:17:23 +00:00
|
|
|
#include "parse-options.h"
|
2021-03-23 14:19:32 +00:00
|
|
|
#include "entry.h"
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
#include "parallel-checkout.h"
|
2023-05-16 06:33:56 +00:00
|
|
|
#include "read-cache-ll.h"
|
2023-03-21 06:26:05 +00:00
|
|
|
#include "setup.h"
|
2023-05-16 06:33:51 +00:00
|
|
|
#include "sparse-index.h"
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2006-03-05 08:24:15 +00:00
|
|
|
#define CHECKOUT_ALL 4
|
2016-01-14 00:14:48 +00:00
|
|
|
static int nul_term_line;
|
2005-12-07 08:29:51 +00:00
|
|
|
static int checkout_stage; /* default to checkout stage0 */
|
2022-01-11 18:05:02 +00:00
|
|
|
static int ignore_skip_worktree; /* default to 0 */
|
checkout-index: delay automatic setting of to_tempfile
Using --stage=all requires writing to tempfiles, since we cannot put
multiple stages into a single file. So --stage=all implies --temp.
But we do so by setting to_tempfile in the options callback for --stage,
rather than after all options have been parsed. This leads to two bugs:
1. If you run "checkout-index --stage=all --stage=2", this should not
imply --temp, but it currently does. The callback cannot just unset
to_tempfile when it sees the "2" value, because it no longer knows
if its value was from the earlier --stage call, or if the user
specified --temp explicitly.
2. If you run "checkout-index --stage=all --no-temp", the --no-temp
will overwrite the earlier implied --temp. But this mode of
operation cannot work, and the command will fail with "<path>
already exists" when trying to write the higher stages.
We can fix both by lazily setting to_tempfile. We'll make it a tristate,
with -1 as "not yet given", and have --stage=all enable it only after
all options are parsed. Likewise, after all options are parsed we can
detect and reject the bogus "--no-temp" case.
Note that this does technically change the behavior for "--stage=all
--no-temp" for paths which have only one stage present (which
accidentally worked before, but is now forbidden). But this behavior was
never intended, and you'd have to go out of your way to try to trigger
it.
The new tests cover both cases, as well the general "--stage=all implies
--temp", as most of the other tests explicitly say "--temp". Ironically,
the test "checkout --temp within subdir" is the only one that _doesn't_
use "--temp", and so was implicitly covering this case. But it seems
reasonable to have a more explicit test alongside the other related
ones.
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-09-05 07:12:59 +00:00
|
|
|
static int to_tempfile = -1;
|
2013-10-23 17:52:42 +00:00
|
|
|
static char topath[4][TEMPORARY_FILENAME_LENGTH + 1];
|
2005-11-26 08:22:48 +00:00
|
|
|
|
2016-09-22 16:11:33 +00:00
|
|
|
static struct checkout state = CHECKOUT_INIT;
|
2005-04-09 16:53:05 +00:00
|
|
|
|
checkout-index: fix --temp relative path mangling
checkout-index --temp only properly prints relative paths which are
descendants of the current directory. Paths in ancestor or sibling
directories (or their children) are often printed in mangled form. For
example:
mkdir a bbb &&
>file &&
>bbb/file &&
git update-index --add file bbb/file &&
cd a &&
git checkout-index --temp ../file ../bbb/file
prints:
.merge_file_ooblek le
.merge_file_igloo0 b/file
rather than the correct:
.merge_file_ooblek ../file
.merge_file_igloo0 ../bbb/file
Internally, given the above example, checkout-index prefixes each input
argument with the name of the current directory ("a/", in this case),
and then assumes that it can simply skip forward by strlen("a/") bytes
to recover the original name. This works for files in the current
directory or its descendants, but fails for files in ancestors or
siblings (or their children) due to path normalization.
For instance, given "../file", "a/" is prepended, giving "a/../file".
Path normalization folds out "a/../", resulting in "file". Attempting
to recover the original name by skipping strlen("a/") bytes gives the
incorrect "le" rather than the desired "../file".
Fix this by taking advantage of write_name_quoted_relative() to recover
the original name properly, rather than assuming that it can be
recovered by skipping strlen(prefix) bytes.
As a bonus, this also fixes a bug in which checkout-index --temp
accessed and printed memory beyond the end-of-string. For instance,
within a subdirectory named "subdirectory", and given argument
"../file", prefixing would give "subdirectory/../file", which would
become "file" after normalization. checkout-index would then attempt to
recover the original name by skipping strlen("subdirectory/") bytes of
"file", which placed it well beyond end-of-string. Despite this error,
it often appeared to give the correct result, but only due to an
accident of implementation which left an apparently correct copy of the
path in memory following the normalized value. In particular, handed
"subdirectory/../file", in-place processing by normalize_path_copy_len()
resulted in "file\0rectory/../file". When checkout-index skipped
strlen("subdirectory/") bytes, it ended up back at "../file" and thus
appeared to give the correct answer, despite being past end-of-string.
Reported-by: Russ Cox <rsc@golang.org>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-24 09:43:16 +00:00
|
|
|
static void write_tempfile_record(const char *name, const char *prefix)
|
2006-03-05 08:24:15 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
2021-02-16 14:06:52 +00:00
|
|
|
int have_tempname = 0;
|
2006-03-05 08:24:15 +00:00
|
|
|
|
|
|
|
|
if (CHECKOUT_ALL == checkout_stage) {
|
2021-02-16 14:06:52 +00:00
|
|
|
for (i = 1; i < 4; i++)
|
|
|
|
|
if (topath[i][0]) {
|
|
|
|
|
have_tempname = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (have_tempname) {
|
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
|
if (i > 1)
|
|
|
|
|
putchar(' ');
|
|
|
|
|
if (topath[i][0])
|
|
|
|
|
fputs(topath[i], stdout);
|
|
|
|
|
else
|
|
|
|
|
putchar('.');
|
|
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
}
|
2021-02-16 14:06:52 +00:00
|
|
|
} else if (topath[checkout_stage][0]) {
|
|
|
|
|
have_tempname = 1;
|
2006-03-05 08:24:15 +00:00
|
|
|
fputs(topath[checkout_stage], stdout);
|
2021-02-16 14:06:52 +00:00
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
|
2021-02-16 14:06:52 +00:00
|
|
|
if (have_tempname) {
|
|
|
|
|
putchar('\t');
|
|
|
|
|
write_name_quoted_relative(name, prefix, stdout,
|
|
|
|
|
nul_term_line ? '\0' : '\n');
|
|
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
|
topath[i][0] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
checkout-index: fix --temp relative path mangling
checkout-index --temp only properly prints relative paths which are
descendants of the current directory. Paths in ancestor or sibling
directories (or their children) are often printed in mangled form. For
example:
mkdir a bbb &&
>file &&
>bbb/file &&
git update-index --add file bbb/file &&
cd a &&
git checkout-index --temp ../file ../bbb/file
prints:
.merge_file_ooblek le
.merge_file_igloo0 b/file
rather than the correct:
.merge_file_ooblek ../file
.merge_file_igloo0 ../bbb/file
Internally, given the above example, checkout-index prefixes each input
argument with the name of the current directory ("a/", in this case),
and then assumes that it can simply skip forward by strlen("a/") bytes
to recover the original name. This works for files in the current
directory or its descendants, but fails for files in ancestors or
siblings (or their children) due to path normalization.
For instance, given "../file", "a/" is prepended, giving "a/../file".
Path normalization folds out "a/../", resulting in "file". Attempting
to recover the original name by skipping strlen("a/") bytes gives the
incorrect "le" rather than the desired "../file".
Fix this by taking advantage of write_name_quoted_relative() to recover
the original name properly, rather than assuming that it can be
recovered by skipping strlen(prefix) bytes.
As a bonus, this also fixes a bug in which checkout-index --temp
accessed and printed memory beyond the end-of-string. For instance,
within a subdirectory named "subdirectory", and given argument
"../file", prefixing would give "subdirectory/../file", which would
become "file" after normalization. checkout-index would then attempt to
recover the original name by skipping strlen("subdirectory/") bytes of
"file", which placed it well beyond end-of-string. Despite this error,
it often appeared to give the correct result, but only due to an
accident of implementation which left an apparently correct copy of the
path in memory following the normalized value. In particular, handed
"subdirectory/../file", in-place processing by normalize_path_copy_len()
resulted in "file\0rectory/../file". When checkout-index skipped
strlen("subdirectory/") bytes, it ended up back at "../file" and thus
appeared to give the correct answer, despite being past end-of-string.
Reported-by: Russ Cox <rsc@golang.org>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-24 09:43:16 +00:00
|
|
|
static int checkout_file(const char *name, const char *prefix)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-12-07 08:29:51 +00:00
|
|
|
int namelen = strlen(name);
|
2022-11-19 13:07:38 +00:00
|
|
|
int pos = index_name_pos(&the_index, name, namelen);
|
2005-12-07 08:29:51 +00:00
|
|
|
int has_same_name = 0;
|
2022-01-11 18:05:03 +00:00
|
|
|
int is_file = 0;
|
2022-01-11 18:05:02 +00:00
|
|
|
int is_skipped = 1;
|
2006-03-05 08:24:15 +00:00
|
|
|
int did_checkout = 0;
|
|
|
|
|
int errs = 0;
|
2005-12-07 08:29:51 +00:00
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
|
pos = -pos - 1;
|
|
|
|
|
|
2022-11-19 13:07:34 +00:00
|
|
|
while (pos < the_index.cache_nr) {
|
|
|
|
|
struct cache_entry *ce = the_index.cache[pos];
|
2005-12-14 05:39:56 +00:00
|
|
|
if (ce_namelen(ce) != namelen ||
|
2005-12-07 08:29:51 +00:00
|
|
|
memcmp(ce->name, name, namelen))
|
|
|
|
|
break;
|
|
|
|
|
has_same_name = 1;
|
|
|
|
|
pos++;
|
2022-01-11 18:05:03 +00:00
|
|
|
if (S_ISSPARSEDIR(ce->ce_mode))
|
|
|
|
|
break;
|
|
|
|
|
is_file = 1;
|
2022-01-11 18:05:02 +00:00
|
|
|
if (!ignore_skip_worktree && ce_skip_worktree(ce))
|
|
|
|
|
break;
|
|
|
|
|
is_skipped = 0;
|
2006-03-05 08:24:15 +00:00
|
|
|
if (ce_stage(ce) != checkout_stage
|
|
|
|
|
&& (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
|
|
|
|
|
continue;
|
|
|
|
|
did_checkout = 1;
|
|
|
|
|
if (checkout_entry(ce, &state,
|
2018-11-13 18:28:00 +00:00
|
|
|
to_tempfile ? topath[ce_stage(ce)] : NULL,
|
|
|
|
|
NULL) < 0)
|
2006-03-05 08:24:15 +00:00
|
|
|
errs++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (did_checkout) {
|
|
|
|
|
if (to_tempfile)
|
checkout-index: fix --temp relative path mangling
checkout-index --temp only properly prints relative paths which are
descendants of the current directory. Paths in ancestor or sibling
directories (or their children) are often printed in mangled form. For
example:
mkdir a bbb &&
>file &&
>bbb/file &&
git update-index --add file bbb/file &&
cd a &&
git checkout-index --temp ../file ../bbb/file
prints:
.merge_file_ooblek le
.merge_file_igloo0 b/file
rather than the correct:
.merge_file_ooblek ../file
.merge_file_igloo0 ../bbb/file
Internally, given the above example, checkout-index prefixes each input
argument with the name of the current directory ("a/", in this case),
and then assumes that it can simply skip forward by strlen("a/") bytes
to recover the original name. This works for files in the current
directory or its descendants, but fails for files in ancestors or
siblings (or their children) due to path normalization.
For instance, given "../file", "a/" is prepended, giving "a/../file".
Path normalization folds out "a/../", resulting in "file". Attempting
to recover the original name by skipping strlen("a/") bytes gives the
incorrect "le" rather than the desired "../file".
Fix this by taking advantage of write_name_quoted_relative() to recover
the original name properly, rather than assuming that it can be
recovered by skipping strlen(prefix) bytes.
As a bonus, this also fixes a bug in which checkout-index --temp
accessed and printed memory beyond the end-of-string. For instance,
within a subdirectory named "subdirectory", and given argument
"../file", prefixing would give "subdirectory/../file", which would
become "file" after normalization. checkout-index would then attempt to
recover the original name by skipping strlen("subdirectory/") bytes of
"file", which placed it well beyond end-of-string. Despite this error,
it often appeared to give the correct result, but only due to an
accident of implementation which left an apparently correct copy of the
path in memory following the normalized value. In particular, handed
"subdirectory/../file", in-place processing by normalize_path_copy_len()
resulted in "file\0rectory/../file". When checkout-index skipped
strlen("subdirectory/") bytes, it ended up back at "../file" and thus
appeared to give the correct answer, despite being past end-of-string.
Reported-by: Russ Cox <rsc@golang.org>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-24 09:43:16 +00:00
|
|
|
write_tempfile_record(name, prefix);
|
2006-03-05 08:24:15 +00:00
|
|
|
return errs > 0 ? -1 : 0;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-12-07 08:29:51 +00:00
|
|
|
|
checkout-index: drop error message from empty --stage=all
If checkout-index is given --stage=all for a specific path, it will try
to write stages 1-3 (if present) for that path to temporary files.
However, if the file is present only at stage 0, it writes nothing but
gives a confusing message:
$ git checkout-index --stage=all -- Makefile
git checkout-index: Makefile does not exist at stage 4
This is nonsense. There is no stage 4 (it's just an internal enum value
we use for "all"), and the documentation clearly states:
Paths which only have a stage 0 entry will always be omitted from the
output.
Here it's talking about the list of tempfiles written to stdout, but it
seems clear that this case was not meant to be an error. We even have a
test which covers it, but it only checks that the command reports an
exit code of 0, not its stderr. And it reports 0 only because of another
bug which fails to propagate errors (which will be fixed in a subsequent
patch).
So let's make the test more thorough. We'll also cover the case that we
found _no_ entry, not even a stage zero, which should still be an error.
However, because of the other bug, we'll have to mark this as expecting
failure for the moment.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-10-27 07:36:02 +00:00
|
|
|
/*
|
|
|
|
|
* At this point we know we didn't try to check anything out. If it was
|
|
|
|
|
* because we did find an entry but it was stage 0, that's not an
|
|
|
|
|
* error.
|
|
|
|
|
*/
|
|
|
|
|
if (has_same_name && checkout_stage == CHECKOUT_ALL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2005-12-07 08:29:51 +00:00
|
|
|
if (!state.quiet) {
|
2008-09-09 10:28:30 +00:00
|
|
|
fprintf(stderr, "git checkout-index: %s ", name);
|
2005-12-07 08:29:51 +00:00
|
|
|
if (!has_same_name)
|
|
|
|
|
fprintf(stderr, "is not in the cache");
|
2022-01-11 18:05:03 +00:00
|
|
|
else if (!is_file)
|
|
|
|
|
fprintf(stderr, "is a sparse directory");
|
2022-01-11 18:05:02 +00:00
|
|
|
else if (is_skipped)
|
|
|
|
|
fprintf(stderr, "has skip-worktree enabled; "
|
|
|
|
|
"use '--ignore-skip-worktree-bits' to checkout");
|
2005-12-07 08:29:51 +00:00
|
|
|
else if (checkout_stage)
|
|
|
|
|
fprintf(stderr, "does not exist at stage %d",
|
|
|
|
|
checkout_stage);
|
|
|
|
|
else
|
|
|
|
|
fprintf(stderr, "is unmerged");
|
|
|
|
|
fputc('\n', stderr);
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
static int checkout_all(const char *prefix, int prefix_length)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-10-03 19:44:48 +00:00
|
|
|
int i, errs = 0;
|
2009-05-01 09:06:36 +00:00
|
|
|
struct cache_entry *last_ce = NULL;
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2022-11-19 13:07:34 +00:00
|
|
|
for (i = 0; i < the_index.cache_nr ; i++) {
|
|
|
|
|
struct cache_entry *ce = the_index.cache[i];
|
2022-01-11 18:05:03 +00:00
|
|
|
|
|
|
|
|
if (S_ISSPARSEDIR(ce->ce_mode)) {
|
|
|
|
|
if (!ce_skip_worktree(ce))
|
|
|
|
|
BUG("sparse directory '%s' does not have skip-worktree set", ce->name);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the current entry is a sparse directory and skip-worktree
|
|
|
|
|
* entries are being checked out, expand the index and continue
|
|
|
|
|
* the loop on the current index position (now pointing to the
|
|
|
|
|
* first entry inside the expanded sparse directory).
|
|
|
|
|
*/
|
|
|
|
|
if (ignore_skip_worktree) {
|
|
|
|
|
ensure_full_index(&the_index);
|
2022-11-19 13:07:34 +00:00
|
|
|
ce = the_index.cache[i];
|
2022-01-11 18:05:03 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-11 18:05:02 +00:00
|
|
|
if (!ignore_skip_worktree && ce_skip_worktree(ce))
|
|
|
|
|
continue;
|
2006-03-05 08:24:15 +00:00
|
|
|
if (ce_stage(ce) != checkout_stage
|
|
|
|
|
&& (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
|
2005-04-18 01:39:14 +00:00
|
|
|
continue;
|
2005-11-26 08:22:48 +00:00
|
|
|
if (prefix && *prefix &&
|
2005-12-07 08:29:51 +00:00
|
|
|
(ce_namelen(ce) <= prefix_length ||
|
|
|
|
|
memcmp(prefix, ce->name, prefix_length)))
|
2005-11-26 08:22:48 +00:00
|
|
|
continue;
|
2006-03-05 08:24:15 +00:00
|
|
|
if (last_ce && to_tempfile) {
|
|
|
|
|
if (ce_namelen(last_ce) != ce_namelen(ce)
|
|
|
|
|
|| memcmp(last_ce->name, ce->name, ce_namelen(ce)))
|
checkout-index: fix --temp relative path mangling
checkout-index --temp only properly prints relative paths which are
descendants of the current directory. Paths in ancestor or sibling
directories (or their children) are often printed in mangled form. For
example:
mkdir a bbb &&
>file &&
>bbb/file &&
git update-index --add file bbb/file &&
cd a &&
git checkout-index --temp ../file ../bbb/file
prints:
.merge_file_ooblek le
.merge_file_igloo0 b/file
rather than the correct:
.merge_file_ooblek ../file
.merge_file_igloo0 ../bbb/file
Internally, given the above example, checkout-index prefixes each input
argument with the name of the current directory ("a/", in this case),
and then assumes that it can simply skip forward by strlen("a/") bytes
to recover the original name. This works for files in the current
directory or its descendants, but fails for files in ancestors or
siblings (or their children) due to path normalization.
For instance, given "../file", "a/" is prepended, giving "a/../file".
Path normalization folds out "a/../", resulting in "file". Attempting
to recover the original name by skipping strlen("a/") bytes gives the
incorrect "le" rather than the desired "../file".
Fix this by taking advantage of write_name_quoted_relative() to recover
the original name properly, rather than assuming that it can be
recovered by skipping strlen(prefix) bytes.
As a bonus, this also fixes a bug in which checkout-index --temp
accessed and printed memory beyond the end-of-string. For instance,
within a subdirectory named "subdirectory", and given argument
"../file", prefixing would give "subdirectory/../file", which would
become "file" after normalization. checkout-index would then attempt to
recover the original name by skipping strlen("subdirectory/") bytes of
"file", which placed it well beyond end-of-string. Despite this error,
it often appeared to give the correct result, but only due to an
accident of implementation which left an apparently correct copy of the
path in memory following the normalized value. In particular, handed
"subdirectory/../file", in-place processing by normalize_path_copy_len()
resulted in "file\0rectory/../file". When checkout-index skipped
strlen("subdirectory/") bytes, it ended up back at "../file" and thus
appeared to give the correct answer, despite being past end-of-string.
Reported-by: Russ Cox <rsc@golang.org>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-24 09:43:16 +00:00
|
|
|
write_tempfile_record(last_ce->name, prefix);
|
2006-03-05 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
if (checkout_entry(ce, &state,
|
2018-11-13 18:28:00 +00:00
|
|
|
to_tempfile ? topath[ce_stage(ce)] : NULL,
|
|
|
|
|
NULL) < 0)
|
2005-10-03 19:44:48 +00:00
|
|
|
errs++;
|
2006-03-05 08:24:15 +00:00
|
|
|
last_ce = ce;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
if (last_ce && to_tempfile)
|
checkout-index: fix --temp relative path mangling
checkout-index --temp only properly prints relative paths which are
descendants of the current directory. Paths in ancestor or sibling
directories (or their children) are often printed in mangled form. For
example:
mkdir a bbb &&
>file &&
>bbb/file &&
git update-index --add file bbb/file &&
cd a &&
git checkout-index --temp ../file ../bbb/file
prints:
.merge_file_ooblek le
.merge_file_igloo0 b/file
rather than the correct:
.merge_file_ooblek ../file
.merge_file_igloo0 ../bbb/file
Internally, given the above example, checkout-index prefixes each input
argument with the name of the current directory ("a/", in this case),
and then assumes that it can simply skip forward by strlen("a/") bytes
to recover the original name. This works for files in the current
directory or its descendants, but fails for files in ancestors or
siblings (or their children) due to path normalization.
For instance, given "../file", "a/" is prepended, giving "a/../file".
Path normalization folds out "a/../", resulting in "file". Attempting
to recover the original name by skipping strlen("a/") bytes gives the
incorrect "le" rather than the desired "../file".
Fix this by taking advantage of write_name_quoted_relative() to recover
the original name properly, rather than assuming that it can be
recovered by skipping strlen(prefix) bytes.
As a bonus, this also fixes a bug in which checkout-index --temp
accessed and printed memory beyond the end-of-string. For instance,
within a subdirectory named "subdirectory", and given argument
"../file", prefixing would give "subdirectory/../file", which would
become "file" after normalization. checkout-index would then attempt to
recover the original name by skipping strlen("subdirectory/") bytes of
"file", which placed it well beyond end-of-string. Despite this error,
it often appeared to give the correct result, but only due to an
accident of implementation which left an apparently correct copy of the
path in memory following the normalized value. In particular, handed
"subdirectory/../file", in-place processing by normalize_path_copy_len()
resulted in "file\0rectory/../file". When checkout-index skipped
strlen("subdirectory/") bytes, it ended up back at "../file" and thus
appeared to give the correct answer, despite being past end-of-string.
Reported-by: Russ Cox <rsc@golang.org>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-24 09:43:16 +00:00
|
|
|
write_tempfile_record(last_ce->name, prefix);
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
return !!errs;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
|
2008-10-18 01:17:23 +00:00
|
|
|
static const char * const builtin_checkout_index_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git checkout-index [<options>] [--] [<file>...]"),
|
2008-10-18 01:17:23 +00:00
|
|
|
NULL
|
|
|
|
|
};
|
2005-07-14 03:25:07 +00:00
|
|
|
|
2008-10-18 01:17:23 +00:00
|
|
|
static int option_parse_stage(const struct option *opt,
|
|
|
|
|
const char *arg, int unset)
|
|
|
|
|
{
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 21:21:07 +00:00
|
|
|
int *stage = opt->value;
|
|
|
|
|
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
|
|
2008-10-18 01:17:23 +00:00
|
|
|
if (!strcmp(arg, "all")) {
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 21:21:07 +00:00
|
|
|
*stage = CHECKOUT_ALL;
|
2008-10-18 01:17:23 +00:00
|
|
|
} else {
|
|
|
|
|
int ch = arg[0];
|
|
|
|
|
if ('1' <= ch && ch <= '3')
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 21:21:07 +00:00
|
|
|
*stage = arg[0] - '0';
|
2008-10-18 01:17:23 +00:00
|
|
|
else
|
2016-02-01 03:18:24 +00:00
|
|
|
die(_("stage should be between 1 and 3 or all"));
|
2008-10-18 01:17:23 +00:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-04 08:23:19 +00:00
|
|
|
int cmd_checkout_index(int argc, const char **argv, const char *prefix)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-10-18 00:32:12 +00:00
|
|
|
int i;
|
2017-10-05 20:32:07 +00:00
|
|
|
struct lock_file lock_file = LOCK_INIT;
|
2005-10-18 00:32:12 +00:00
|
|
|
int all = 0;
|
2006-03-01 02:43:33 +00:00
|
|
|
int read_from_stdin = 0;
|
2006-08-04 08:23:19 +00:00
|
|
|
int prefix_length;
|
2008-10-18 01:17:23 +00:00
|
|
|
int force = 0, quiet = 0, not_new = 0;
|
checkout-index: handle "--no-index" option
The parsing of "--index" is done in a callback, but it does
not handle an "unset" option. We don't necessarily expect
anyone to use this, but the current behavior is to treat it
exactly like "--index", which would probably be surprising.
Instead, let's just turn it into an OPT_BOOL, and handle it
after we're done parsing. This makes "--no-index" just work
(it cancels a previous "--index").
As a bonus, this makes the logic easier to follow. The old
code opened the index during the option parsing, leaving the
reader to wonder if there was some timing issue (there
isn't; none of the other options care that we've opened it).
And then if we found that "--prefix" had been given, we had
to rollback the index. Now we can simply avoid opening it in
the first place.
Note that it might make more sense for checkout-index to
complain when "--index --prefix=foo" is given (rather than
silently ignoring "--index"), but since it has been that way
since 415e96c ([PATCH] Implement git-checkout-cache -u to
update stat information in the cache., 2005-05-15), it's
safer to leave it as-is.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-31 11:29:36 +00:00
|
|
|
int index_opt = 0;
|
2020-10-27 07:37:14 +00:00
|
|
|
int err = 0;
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
int pc_workers, pc_threshold;
|
2008-10-18 01:17:23 +00:00
|
|
|
struct option builtin_checkout_index_options[] = {
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('a', "all", &all,
|
2012-08-20 12:32:55 +00:00
|
|
|
N_("check out all files in the index")),
|
2022-01-11 18:05:02 +00:00
|
|
|
OPT_BOOL(0, "ignore-skip-worktree-bits", &ignore_skip_worktree,
|
|
|
|
|
N_("do not skip files with skip-worktree set")),
|
2018-02-09 11:01:42 +00:00
|
|
|
OPT__FORCE(&force, N_("force overwrite of existing files"), 0),
|
2010-11-08 19:54:48 +00:00
|
|
|
OPT__QUIET(&quiet,
|
2012-08-20 12:31:58 +00:00
|
|
|
N_("no warning for existing files and files not in index")),
|
2013-08-03 11:51:25 +00:00
|
|
|
OPT_BOOL('n', "no-create", ¬_new,
|
2012-08-20 12:31:58 +00:00
|
|
|
N_("don't checkout new files")),
|
checkout-index: handle "--no-index" option
The parsing of "--index" is done in a callback, but it does
not handle an "unset" option. We don't necessarily expect
anyone to use this, but the current behavior is to treat it
exactly like "--index", which would probably be surprising.
Instead, let's just turn it into an OPT_BOOL, and handle it
after we're done parsing. This makes "--no-index" just work
(it cancels a previous "--index").
As a bonus, this makes the logic easier to follow. The old
code opened the index during the option parsing, leaving the
reader to wonder if there was some timing issue (there
isn't; none of the other options care that we've opened it).
And then if we found that "--prefix" had been given, we had
to rollback the index. Now we can simply avoid opening it in
the first place.
Note that it might make more sense for checkout-index to
complain when "--index --prefix=foo" is given (rather than
silently ignoring "--index"), but since it has been that way
since 415e96c ([PATCH] Implement git-checkout-cache -u to
update stat information in the cache., 2005-05-15), it's
safer to leave it as-is.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-31 11:29:36 +00:00
|
|
|
OPT_BOOL('u', "index", &index_opt,
|
|
|
|
|
N_("update stat information in the index file")),
|
2016-01-31 11:25:43 +00:00
|
|
|
OPT_BOOL('z', NULL, &nul_term_line,
|
|
|
|
|
N_("paths are separated with NUL character")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "stdin", &read_from_stdin,
|
2012-08-20 12:31:58 +00:00
|
|
|
N_("read list of paths from the standard input")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "temp", &to_tempfile,
|
2012-08-20 12:31:58 +00:00
|
|
|
N_("write the content to temporary files")),
|
2016-01-31 11:26:16 +00:00
|
|
|
OPT_STRING(0, "prefix", &state.base_dir, N_("string"),
|
|
|
|
|
N_("when creating files, prepend <string>")),
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 21:21:07 +00:00
|
|
|
OPT_CALLBACK_F(0, "stage", &checkout_stage, "(1|2|3|all)",
|
2012-08-20 12:31:58 +00:00
|
|
|
N_("copy out the files from named stage"),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
PARSE_OPT_NONEG, option_parse_stage),
|
2008-10-18 01:17:23 +00:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2010-10-22 06:44:01 +00:00
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
|
|
|
usage_with_options(builtin_checkout_index_usage,
|
|
|
|
|
builtin_checkout_index_options);
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2005-11-26 08:22:48 +00:00
|
|
|
prefix_length = prefix ? strlen(prefix) : 0;
|
|
|
|
|
|
2022-01-11 18:05:03 +00:00
|
|
|
prepare_repo_settings(the_repository);
|
|
|
|
|
the_repository->settings.command_requires_full_index = 0;
|
|
|
|
|
|
2022-11-19 13:07:38 +00:00
|
|
|
if (repo_read_index(the_repository) < 0) {
|
2005-04-13 09:28:48 +00:00
|
|
|
die("invalid cache");
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_checkout_index_options,
|
2008-10-18 01:17:23 +00:00
|
|
|
builtin_checkout_index_usage, 0);
|
2018-08-13 16:14:32 +00:00
|
|
|
state.istate = &the_index;
|
2008-10-18 01:17:23 +00:00
|
|
|
state.force = force;
|
|
|
|
|
state.quiet = quiet;
|
|
|
|
|
state.not_new = not_new;
|
2005-10-18 00:32:12 +00:00
|
|
|
|
2016-01-31 11:26:16 +00:00
|
|
|
if (!state.base_dir)
|
|
|
|
|
state.base_dir = "";
|
|
|
|
|
state.base_dir_len = strlen(state.base_dir);
|
|
|
|
|
|
checkout-index: delay automatic setting of to_tempfile
Using --stage=all requires writing to tempfiles, since we cannot put
multiple stages into a single file. So --stage=all implies --temp.
But we do so by setting to_tempfile in the options callback for --stage,
rather than after all options have been parsed. This leads to two bugs:
1. If you run "checkout-index --stage=all --stage=2", this should not
imply --temp, but it currently does. The callback cannot just unset
to_tempfile when it sees the "2" value, because it no longer knows
if its value was from the earlier --stage call, or if the user
specified --temp explicitly.
2. If you run "checkout-index --stage=all --no-temp", the --no-temp
will overwrite the earlier implied --temp. But this mode of
operation cannot work, and the command will fail with "<path>
already exists" when trying to write the higher stages.
We can fix both by lazily setting to_tempfile. We'll make it a tristate,
with -1 as "not yet given", and have --stage=all enable it only after
all options are parsed. Likewise, after all options are parsed we can
detect and reject the bogus "--no-temp" case.
Note that this does technically change the behavior for "--stage=all
--no-temp" for paths which have only one stage present (which
accidentally worked before, but is now forbidden). But this behavior was
never intended, and you'd have to go out of your way to try to trigger
it.
The new tests cover both cases, as well the general "--stage=all implies
--temp", as most of the other tests explicitly say "--temp". Ironically,
the test "checkout --temp within subdir" is the only one that _doesn't_
use "--temp", and so was implicitly covering this case. But it seems
reasonable to have a more explicit test alongside the other related
ones.
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-09-05 07:12:59 +00:00
|
|
|
if (to_tempfile < 0)
|
|
|
|
|
to_tempfile = (checkout_stage == CHECKOUT_ALL);
|
|
|
|
|
if (!to_tempfile && checkout_stage == CHECKOUT_ALL)
|
|
|
|
|
die(_("options '%s' and '%s' cannot be used together"),
|
|
|
|
|
"--stage=all", "--no-temp");
|
|
|
|
|
|
checkout-index: handle "--no-index" option
The parsing of "--index" is done in a callback, but it does
not handle an "unset" option. We don't necessarily expect
anyone to use this, but the current behavior is to treat it
exactly like "--index", which would probably be surprising.
Instead, let's just turn it into an OPT_BOOL, and handle it
after we're done parsing. This makes "--no-index" just work
(it cancels a previous "--index").
As a bonus, this makes the logic easier to follow. The old
code opened the index during the option parsing, leaving the
reader to wonder if there was some timing issue (there
isn't; none of the other options care that we've opened it).
And then if we found that "--prefix" had been given, we had
to rollback the index. Now we can simply avoid opening it in
the first place.
Note that it might make more sense for checkout-index to
complain when "--index --prefix=foo" is given (rather than
silently ignoring "--index"), but since it has been that way
since 415e96c ([PATCH] Implement git-checkout-cache -u to
update stat information in the cache., 2005-05-15), it's
safer to leave it as-is.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-31 11:29:36 +00:00
|
|
|
/*
|
|
|
|
|
* when --prefix is specified we do not want to update cache.
|
|
|
|
|
*/
|
|
|
|
|
if (index_opt && !state.base_dir_len && !to_tempfile) {
|
|
|
|
|
state.refresh_cache = 1;
|
|
|
|
|
state.istate = &the_index;
|
2022-11-19 13:07:38 +00:00
|
|
|
repo_hold_locked_index(the_repository, &lock_file,
|
|
|
|
|
LOCK_DIE_ON_ERROR);
|
2005-10-18 00:32:12 +00:00
|
|
|
}
|
|
|
|
|
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
get_parallel_checkout_configs(&pc_workers, &pc_threshold);
|
|
|
|
|
if (pc_workers > 1)
|
|
|
|
|
init_parallel_checkout();
|
|
|
|
|
|
2005-10-18 00:32:12 +00:00
|
|
|
/* Check out named files first */
|
2008-10-18 01:17:23 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2005-10-18 00:32:12 +00:00
|
|
|
const char *arg = argv[i];
|
2015-05-04 19:11:54 +00:00
|
|
|
char *p;
|
2005-10-18 00:32:12 +00:00
|
|
|
|
|
|
|
|
if (all)
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git checkout-index: don't mix '--all' and explicit filenames");
|
2006-03-01 02:43:33 +00:00
|
|
|
if (read_from_stdin)
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git checkout-index: don't mix '--stdin' and explicit filenames");
|
2006-05-06 05:38:06 +00:00
|
|
|
p = prefix_path(prefix, prefix_length, arg);
|
2020-10-27 07:37:14 +00:00
|
|
|
err |= checkout_file(p, prefix);
|
2015-05-04 19:11:54 +00:00
|
|
|
free(p);
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-05-15 21:23:12 +00:00
|
|
|
|
2006-03-01 02:43:33 +00:00
|
|
|
if (read_from_stdin) {
|
2016-01-31 11:25:26 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
struct strbuf unquoted = STRBUF_INIT;
|
2016-01-14 00:14:48 +00:00
|
|
|
strbuf_getline_fn getline_fn;
|
2007-09-19 22:42:14 +00:00
|
|
|
|
2006-03-01 02:43:33 +00:00
|
|
|
if (all)
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git checkout-index: don't mix '--all' and '--stdin'");
|
2007-09-19 22:42:14 +00:00
|
|
|
|
2016-01-14 00:14:48 +00:00
|
|
|
getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
|
|
|
|
|
while (getline_fn(&buf, stdin) != EOF) {
|
2015-05-04 19:11:54 +00:00
|
|
|
char *p;
|
2016-01-14 00:14:48 +00:00
|
|
|
if (!nul_term_line && buf.buf[0] == '"') {
|
2016-01-31 11:25:26 +00:00
|
|
|
strbuf_reset(&unquoted);
|
|
|
|
|
if (unquote_c_style(&unquoted, buf.buf, NULL))
|
2007-09-19 22:42:14 +00:00
|
|
|
die("line is badly quoted");
|
2016-01-31 11:25:26 +00:00
|
|
|
strbuf_swap(&buf, &unquoted);
|
2007-09-19 22:42:14 +00:00
|
|
|
}
|
|
|
|
|
p = prefix_path(prefix, prefix_length, buf.buf);
|
2020-10-27 07:37:14 +00:00
|
|
|
err |= checkout_file(p, prefix);
|
2015-05-04 19:11:54 +00:00
|
|
|
free(p);
|
2006-03-01 02:43:33 +00:00
|
|
|
}
|
2016-01-31 11:25:26 +00:00
|
|
|
strbuf_release(&unquoted);
|
2007-09-17 09:19:04 +00:00
|
|
|
strbuf_release(&buf);
|
2006-03-01 02:43:33 +00:00
|
|
|
}
|
|
|
|
|
|
checkout-index: add parallel checkout support
Allow checkout-index to use the parallel checkout framework, honoring
the checkout.workers configuration.
There are two code paths in checkout-index which call
`checkout_entry()`, and thus, can make use of parallel checkout:
`checkout_file()`, which is used to write paths explicitly given at the
command line; and `checkout_all()`, which is used to write all paths in
the index, when the `--all` option is given.
In both operation modes, checkout-index doesn't abort immediately on a
`checkout_entry()` failure. Instead, it tries to check out all remaining
paths before exiting with a non-zero exit code. To keep this behavior
when parallel checkout is being used, we must allow
`run_parallel_checkout()` to try writing the queued entries before we
exit, even if we already got an error code from a previous
`checkout_entry()` call.
However, `checkout_all()` doesn't return on errors, it calls `exit()`
with code 128. We could make it call `run_parallel_checkout()` before
exiting, but it makes the code easier to follow if we unify the exit
path for both checkout-index modes at `cmd_checkout_index()`, and let
this function take care of the interactions with the parallel checkout
API. So let's do that.
With this change, we also have to consider whether we want to keep using
128 as the error code for `git checkout-index --all`, while we use 1 for
`git checkout-index <path>` (even when the actual error is the same).
Since there is not much value in having code 128 only for `--all`, and
there is no mention about it in the docs (so it's unlikely that changing
it will break any existing script), let's make both modes exit with code
1 on `checkout_entry()` errors.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 16:27:30 +00:00
|
|
|
if (all)
|
|
|
|
|
err |= checkout_all(prefix, prefix_length);
|
|
|
|
|
|
|
|
|
|
if (pc_workers > 1)
|
|
|
|
|
err |= run_parallel_checkout(&state, pc_workers, pc_threshold,
|
|
|
|
|
NULL, NULL);
|
|
|
|
|
|
2020-10-27 07:37:14 +00:00
|
|
|
if (err)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2017-10-05 20:32:07 +00:00
|
|
|
if (is_lock_file_locked(&lock_file) &&
|
2014-06-13 12:19:23 +00:00
|
|
|
write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
|
2006-06-06 19:51:49 +00:00
|
|
|
die("Unable to write new index file");
|
2005-04-09 16:53:05 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|