From: Li Linchao via GitGitGadget <hidden> Date: 2021-02-04 03:32:36
From: lilinchao <redacted>
This patch add a new option that reject to clone a shallow repository.
Clients don't know it's a shallow repository until they download it
locally, in some scenariors, clients just don't want to clone this kind
of repository, and want to exit the process immediately without creating
any unnecessary files.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --no-shallow option
This patch add a new option that reject to clone a shallow repository.
Clients don't know it's a shallow repository until they download it
locally, in some scenariors, clients just don't want to clone this kind
of repository, and want to exit the process immediately without creating
any unnecessary files.
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v1
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v1
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Documentation/config/clone.txt | 3 +++
Documentation/git-clone.txt | 8 +++++++-
builtin/clone.c | 13 +++++++++++++
t/t5606-clone-options.sh | 7 +++++++
t/t5611-clone-config.sh | 7 +++++++
5 files changed, 37 insertions(+), 1 deletion(-)
mode change 100644 => 100755 builtin/clone.c
@@ -2,3 +2,6 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectshallow::+ Reject to clone a repository if it is a shallow one.
@@ -145,6 +145,12 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--no-shallow::+ Don't clone a shallow source repository. In some scenariors, clients+ want the cloned repository information to be complete. Otherwise,+ the cloning process should end immediately without creating any files,+ which can save some disk space.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -963,6 +968,7 @@ static int path_exists(const char *path)intcmd_clone(intargc,constchar**argv,constchar*prefix){intis_bundle=0,is_local;+intis_shallow=0;constchar*repo_name,*repo,*work_tree,*git_dir;char*path,*dir,*display_repo=NULL;intdest_exists,real_dest_exists=0;
@@ -1215,6 +1221,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+is_shallow=1;if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -1222,6 +1229,12 @@ int cmd_clone(int argc, const char **argv, const char *prefix)}if(option_local>0&&!is_local)warning(_("--local is ignored"));++if(is_shallow){+if(option_no_shallow)+die(_("source repository is shallow, reject to clone."));+}+transport->cloning=1;transport_set_option(transport,TRANS_OPT_KEEP,"yes");
From: lilinchao via GitGitGadget <hidden> Date: 2021-02-08 08:33:42
From: lilinchao <redacted>
This patch add a new option that reject to clone a shallow repository.
Clients don't know it's a shallow repository until they download it
locally, in some scenariors, clients just don't want to clone this kind
of repository, and want to exit the process immediately without creating
any unnecessary files.
Signed-off-by: lilinchao <redacted>
---
Documentation/config/clone.txt | 3 +++
Documentation/git-clone.txt | 8 +++++++-
builtin/clone.c | 13 +++++++++++++
t/t5606-clone-options.sh | 7 +++++++
t/t5611-clone-config.sh | 7 +++++++
5 files changed, 37 insertions(+), 1 deletion(-)
mode change 100644 => 100755 builtin/clone.c
@@ -2,3 +2,6 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectshallow::+ Reject to clone a repository if it is a shallow one.
@@ -149,6 +149,12 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--no-shallow::+ Don't clone a shallow source repository. In some scenariors, clients+ want the cloned repository information to be complete. Otherwise,+ the cloning process should end immediately without creating any files,+ which can save some disk space.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -963,6 +968,7 @@ static int path_exists(const char *path)intcmd_clone(intargc,constchar**argv,constchar*prefix){intis_bundle=0,is_local;+intis_shallow=0;constchar*repo_name,*repo,*work_tree,*git_dir;char*path,*dir,*display_repo=NULL;intdest_exists,real_dest_exists=0;
@@ -1215,6 +1221,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+is_shallow=1;if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -1222,6 +1229,12 @@ int cmd_clone(int argc, const char **argv, const char *prefix)}if(option_local>0&&!is_local)warning(_("--local is ignored"));++if(is_shallow){+if(option_no_shallow)+die(_("source repository is shallow, reject to clone."));+}+transport->cloning=1;transport_set_option(transport,TRANS_OPT_KEEP,"yes");
From: lilinchao via GitGitGadget <hidden> Date: 2021-02-08 08:34:13
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which mostly to be a shallow repository, can
give them. But users don't know it is a shallow repository until
they download it to local, users should have the option to refuse
to clone this kind of repository, and may want to exit the process
immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, given that we have an API that allow us to import
external repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import an unshallow repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
Documentation/config/clone.txt | 3 ++-
Documentation/git-clone.txt | 20 ++++++++++++++++----
builtin/clone.c | 32 ++++++++++++++++++++++++++------
t/t5606-clone-options.sh | 33 +++++++++++++++++++++++++++++++--
t/t5611-clone-config.sh | 29 +++++++++++++++++++++++++++--
5 files changed, 102 insertions(+), 15 deletions(-)
mode change 100755 => 100644 builtin/clone.c
@@ -4,4 +4,5 @@ clone.defaultRemoteName:: option to linkgit:git-clone[1]. clone.rejectshallow::- Reject to clone a repository if it is a shallow one.+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,11 +149,23 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.---no-shallow::- Don't clone a shallow source repository. In some scenariors, clients+--reject-shallow::+ Don't clone a shallow source repository. In some scenarios, clients want the cloned repository information to be complete. Otherwise, the cloning process should end immediately without creating any files,- which can save some disk space.+ which can save some disk space. This can override `clone.rejectshallow`+ from the configuration:++ --------------------------------------------------------------------+ $ git -c clone.rejectshallow=false clone --reject-shallow source out+ --------------------------------------------------------------------++ While there is a way to countermand a configured "I always refuse to+ clone from a shallow repository" with "but let's allow it only this time":++ ----------------------------------------------------------------------+ $ git -c clone.rejectshallow=true clone --no-reject-shallow source out+ ---------------------------------------------------------------------- --bare:: Make a 'bare' Git repository. That is, instead of
@@ -1211,6 +1213,12 @@ int cmd_clone(int argc, const char **argv, const char *prefix)path=get_repo_path(remote->url[0],&is_bundle);is_local=option_local!=0&&path&&!is_bundle;++/* Detect if the remote repository is shallow */+if(!access(mkpath("%s/shallow",path),F_OK)){+is_shallow=1;+}+if(is_local){if(option_depth)warning(_("--depth is ignored in local clones; use file:// instead."));
@@ -1220,8 +1228,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));-if(!access(mkpath("%s/shallow",path),F_OK)){-is_shallow=1;+if(is_shallow){if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -1231,8 +1238,21 @@ int cmd_clone(int argc, const char **argv, const char *prefix)warning(_("--local is ignored"));if(is_shallow){-if(option_no_shallow)+intreject=0;++/* If option_no_shallow is specified from CLI option,+*ignoreconfig_shallowfromgit_clone_config.+*/++if(config_shallow!=-1){+reject=config_shallow;+}+if(option_no_shallow!=-1){+reject=option_no_shallow;+}+if(reject){die(_("source repository is shallow, reject to clone."));+}}transport->cloning=1;
@@ -45,13 +45,42 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''-test_expect_success'reject clone shallow repository''+test_expect_success'fail to clone shallow repository''gitclone--depth=1--no-localparentshallow-repo&&-test_must_failgitclone--no-shallowshallow-repoout2>err&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&test_i18ngrep-e"source repository is shallow, reject to clone."err'+test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
You should rewrite your history to make this one commit again. You can
do this by running 'git rebase -i HEAD~2' then editing the todo file
to 'squash' the second commit in to the first. You will be prompted to
edit the combined commit message, and you should preserve only the message
from the second commit.
Thanks,
-Stolee
From: Li Linchao via GitGitGadget <hidden> Date: 2021-02-08 14:16:19
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which mostly to be a shallow repository, can
give them. But users don't know it is a shallow repository until
they download it to local, users should have the option to refuse
to clone this kind of repository, and may want to exit the process
immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, given that we have an API that allow us to import
external repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import an unshallow repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --no-shallow option
Change since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v3
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v3
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v2:
1: 2f9602495eb5 < -: ------------ builtin/clone.c: add --no-shallow option
2: cfcfc3ec6b37 ! 1: f5ed6b2e4481 builtin/clone.c: add --reject-shallow option
@@ Commit message
## Documentation/config/clone.txt ##
@@ Documentation/config/clone.txt: clone.defaultRemoteName::
+ The name of the remote to create when cloning a repository. Defaults to
+ `origin`, and can be overridden by passing the `--origin` command-line
option to linkgit:git-clone[1].
-
- clone.rejectshallow::
-- Reject to clone a repository if it is a shallow one.
++
++clone.rejectshallow::
+ Reject to clone a repository if it is a shallow one, can be overridden by
+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ Documentation/git-clone.txt: SYNOPSIS
[--dissociate] [--separate-git-dir <git dir>]
[--depth <depth>] [--[no-]single-branch] [--no-tags]
[--recurse-submodules[=<pathspec>]] [--[no-]shallow-submodules]
-- [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--no-shallow]
+- [--[no-]remote-submodules] [--jobs <n>] [--sparse]
+ [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--reject-shallow]
[--filter=<filter>] [--] <repository>
[<directory>]
@@ Documentation/git-clone.txt: objects from the source repository into a pack in t
--no-checkout::
No checkout of HEAD is performed after the clone is complete.
----no-shallow::
-- Don't clone a shallow source repository. In some scenariors, clients
+--reject-shallow::
+ Don't clone a shallow source repository. In some scenarios, clients
- want the cloned repository information to be complete. Otherwise,
- the cloning process should end immediately without creating any files,
-- which can save some disk space.
++ want the cloned repository information to be complete. Otherwise,
++ the cloning process should end immediately without creating any files,
+ which can save some disk space. This can override `clone.rejectshallow`
+ from the configuration:
+
@@ Documentation/git-clone.txt: objects from the source repository into a pack in t
+ ----------------------------------------------------------------------
+ $ git -c clone.rejectshallow=true clone --no-reject-shallow source out
+ ----------------------------------------------------------------------
-
++
--bare::
Make a 'bare' Git repository. That is, instead of
+ creating `<directory>` and placing the administrative
- ## builtin/clone.c (mode change 100755 => 100644) ##
+ ## builtin/clone.c ##
@@ builtin/clone.c: static int option_no_checkout, option_bare, option_mirror, option_single_branch
static int option_local = -1, option_no_hardlinks, option_shared;
static int option_no_tags;
static int option_shallow_submodules;
--static int option_no_shallow;
+static int option_no_shallow = -1; /* unspecified */
+static int config_shallow = -1; /* unspecified */
static int deepen;
@@ builtin/clone.c: static struct option builtin_clone_options[] = {
OPT__VERBOSITY(&option_verbosity),
OPT_BOOL(0, "progress", &option_progress,
N_("force progress reporting")),
-- OPT_BOOL(0, "no-shallow", &option_no_shallow, N_("don't clone shallow repository")),
+ OPT_BOOL(0, "reject-shallow", &option_no_shallow,
+ N_("don't clone shallow repository")),
OPT_BOOL('n', "no-checkout", &option_no_checkout,
N_("don't create a checkout")),
OPT_BOOL(0, "bare", &option_bare, N_("create a bare repository")),
@@ builtin/clone.c: static int git_clone_config(const char *k, const char *v, void *cb)
+ free(remote_name);
remote_name = xstrdup(v);
}
- if (!strcmp(k, "clone.rejectshallow")) {
-- option_no_shallow = 1;
++ if (!strcmp(k, "clone.rejectshallow")) {
+ config_shallow = git_config_bool(k, v);
- }
++ }
return git_default_config(k, v, cb);
}
+
+@@ builtin/clone.c: static int path_exists(const char *path)
+ int cmd_clone(int argc, const char **argv, const char *prefix)
+ {
+ int is_bundle = 0, is_local;
++ int is_shallow = 0;
+ const char *repo_name, *repo, *work_tree, *git_dir;
+ char *path, *dir, *display_repo = NULL;
+ int dest_exists, real_dest_exists = 0;
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
path = get_repo_path(remote->url[0], &is_bundle);
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
if (filter_options.choice)
warning(_("--filter is ignored in local clones; use file:// instead."));
- if (!access(mkpath("%s/shallow", path), F_OK)) {
-- is_shallow = 1;
+ if (is_shallow) {
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ }
+ if (option_local > 0 && !is_local)
warning(_("--local is ignored"));
-
- if (is_shallow) {
-- if (option_no_shallow)
++
++ if (is_shallow) {
+ int reject = 0;
+
+ /* If option_no_shallow is specified from CLI option,
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ reject = option_no_shallow;
+ }
+ if (reject) {
- die(_("source repository is shallow, reject to clone."));
++ die(_("source repository is shallow, reject to clone."));
+ }
- }
-
++ }
++
transport->cloning = 1;
+
+ transport_set_option(transport, TRANS_OPT_KEEP, "yes");
## t/t5606-clone-options.sh ##
@@ t/t5606-clone-options.sh: test_expect_success 'disallows --bare with --separate-git-dir' '
'
--test_expect_success 'reject clone shallow repository' '
+test_expect_success 'fail to clone shallow repository' '
- git clone --depth=1 --no-local parent shallow-repo &&
-- test_must_fail git clone --no-shallow shallow-repo out 2>err &&
++ git clone --depth=1 --no-local parent shallow-repo &&
+ test_must_fail git clone --reject-shallow shallow-repo out 2>err &&
- test_i18ngrep -e "source repository is shallow, reject to clone." err
-
- '
-
++ test_i18ngrep -e "source repository is shallow, reject to clone." err
++
++'
++
+test_expect_success 'fail to clone non-local shallow repository' '
+ rm -rf shallow-repo &&
+ git clone --depth=1 --no-local parent shallow-repo &&
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
test_cmp expect actual
'
--test_expect_success 'clone -c clone.rejectshallow' '
+test_expect_success 'clone.rejectshallow=true should fail to clone' '
- rm -rf child &&
- git clone --depth=1 --no-local . child &&
-- test_must_fail git clone -c clone.rejectshallow child out 2>err &&
++ rm -rf child &&
++ git clone --depth=1 --no-local . child &&
+ test_must_fail git -c clone.rejectshallow=true clone --no-local child out 2>err &&
- test_i18ngrep -e "source repository is shallow, reject to clone." err
- '
-
++ test_i18ngrep -e "source repository is shallow, reject to clone." err
++'
++
+test_expect_success 'clone.rejectshallow=false should succeed cloning' '
+ rm -rf child &&
+ git clone --depth=1 --no-local . child &&
Documentation/config/clone.txt | 4 ++++
Documentation/git-clone.txt | 20 ++++++++++++++++++-
builtin/clone.c | 35 ++++++++++++++++++++++++++++++++-
t/t5606-clone-options.sh | 36 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 ++++++++++++++++++++++++++++++
5 files changed, 125 insertions(+), 2 deletions(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectshallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,24 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--reject-shallow::+ Don't clone a shallow source repository. In some scenarios, clients+ want the cloned repository information to be complete. Otherwise,+ the cloning process should end immediately without creating any files,+ which can save some disk space. This can override `clone.rejectshallow`+ from the configuration:++ --------------------------------------------------------------------+ $ git -c clone.rejectshallow=false clone --reject-shallow source out+ --------------------------------------------------------------------++ While there is a way to countermand a configured "I always refuse to+ clone from a shallow repository" with "but let's allow it only this time":++ ----------------------------------------------------------------------+ $ git -c clone.rejectshallow=true clone --no-reject-shallow source out+ ----------------------------------------------------------------------+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -963,6 +970,7 @@ static int path_exists(const char *path)intcmd_clone(intargc,constchar**argv,constchar*prefix){intis_bundle=0,is_local;+intis_shallow=0;constchar*repo_name,*repo,*work_tree,*git_dir;char*path,*dir,*display_repo=NULL;intdest_exists,real_dest_exists=0;
@@ -1205,6 +1213,12 @@ int cmd_clone(int argc, const char **argv, const char *prefix)path=get_repo_path(remote->url[0],&is_bundle);is_local=option_local!=0&&path&&!is_bundle;++/* Detect if the remote repository is shallow */+if(!access(mkpath("%s/shallow",path),F_OK)){+is_shallow=1;+}+if(is_local){if(option_depth)warning(_("--depth is ignored in local clones; use file:// instead."));
@@ -1214,7 +1228,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));-if(!access(mkpath("%s/shallow",path),F_OK)){+if(is_shallow){if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -1222,6 +1236,25 @@ int cmd_clone(int argc, const char **argv, const char *prefix)}if(option_local>0&&!is_local)warning(_("--local is ignored"));++if(is_shallow){+intreject=0;++/* If option_no_shallow is specified from CLI option,+*ignoreconfig_shallowfromgit_clone_config.+*/++if(config_shallow!=-1){+reject=config_shallow;+}+if(option_no_shallow!=-1){+reject=option_no_shallow;+}+if(reject){+die(_("source repository is shallow, reject to clone."));+}+}+transport->cloning=1;transport_set_option(transport,TRANS_OPT_KEEP,"yes");
@@ -45,6 +45,42 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'fail to clone shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should fail to clone''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed cloning''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed cloning normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgitclone-cclone.rejectshallow=false--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success' option --no-reject-shallow override clone.rejectshallow''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
From: Li Linchao via GitGitGadget <hidden> Date: 2021-02-21 07:06:50
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v4
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v4
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v3:
1: f5ed6b2e4481 ! 1: ee4fb840a32f builtin/clone.c: add --reject-shallow option
@@ Commit message
builtin/clone.c: add --reject-shallow option
In some scenarios, users may want more history than the repository
- offered for cloning, which mostly to be a shallow repository, can
- give them. But users don't know it is a shallow repository until
- they download it to local, users should have the option to refuse
- to clone this kind of repository, and may want to exit the process
- immediately without creating any unnecessary files.
+ offered for cloning, which happens to be a shallow repository, can
+ give them. But because users don't know it is a shallow repository
+ until they download it to local, users should have the option to
+ refuse to clone this kind of repository, and may want to exit the
+ process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
@@ Commit message
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
- In other scenarios, given that we have an API that allow us to import
- external repository, and then perform various operations on the repo.
+ In other scenarios, if we have an API that allow us to import external
+ repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
- clone, and let's just import an unshallow repository.
+ clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
@@ Documentation/git-clone.txt: SYNOPSIS
[--depth <depth>] [--[no-]single-branch] [--no-tags]
[--recurse-submodules[=<pathspec>]] [--[no-]shallow-submodules]
- [--[no-]remote-submodules] [--jobs <n>] [--sparse]
-+ [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--reject-shallow]
++ [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--[no-]reject-shallow]
[--filter=<filter>] [--] <repository>
[<directory>]
@@ Documentation/git-clone.txt: objects from the source repository into a pack in t
--no-checkout::
No checkout of HEAD is performed after the clone is complete.
-+--reject-shallow::
-+ Don't clone a shallow source repository. In some scenarios, clients
-+ want the cloned repository information to be complete. Otherwise,
-+ the cloning process should end immediately without creating any files,
-+ which can save some disk space. This can override `clone.rejectshallow`
-+ from the configuration:
-+
-+ --------------------------------------------------------------------
-+ $ git -c clone.rejectshallow=false clone --reject-shallow source out
-+ --------------------------------------------------------------------
-+
-+ While there is a way to countermand a configured "I always refuse to
-+ clone from a shallow repository" with "but let's allow it only this time":
-+
-+ ----------------------------------------------------------------------
-+ $ git -c clone.rejectshallow=true clone --no-reject-shallow source out
-+ ----------------------------------------------------------------------
++--[no-]reject-shallow::
++ Fail if the source repository is a shallow repository. The
++ 'clone.rejectshallow' configuration variable can be used to
++ give the default.
+
--bare::
Make a 'bare' Git repository. That is, instead of
creating `<directory>` and placing the administrative
## builtin/clone.c ##
+@@
+ #include "connected.h"
+ #include "packfile.h"
+ #include "list-objects-filter-options.h"
++#include "shallow.h"
+
+ /*
+ * Overall FIXMEs:
@@ builtin/clone.c: static int option_no_checkout, option_bare, option_mirror, option_single_branch
static int option_local = -1, option_no_hardlinks, option_shared;
static int option_no_tags;
static int option_shallow_submodules;
-+static int option_no_shallow = -1; /* unspecified */
++static int option_shallow = -1; /* unspecified */
+static int config_shallow = -1; /* unspecified */
static int deepen;
static char *option_template, *option_depth, *option_since;
@@ builtin/clone.c: static struct option builtin_clone_options[] = {
OPT__VERBOSITY(&option_verbosity),
OPT_BOOL(0, "progress", &option_progress,
N_("force progress reporting")),
-+ OPT_BOOL(0, "reject-shallow", &option_no_shallow,
++ OPT_BOOL(0, "reject-shallow", &option_shallow,
+ N_("don't clone shallow repository")),
OPT_BOOL('n', "no-checkout", &option_no_checkout,
N_("don't create a checkout")),
@@ builtin/clone.c: static int path_exists(const char *path)
int cmd_clone(int argc, const char **argv, const char *prefix)
{
int is_bundle = 0, is_local;
-+ int is_shallow = 0;
++ int local_shallow = 0;
++ int reject_shallow = 0;
const char *repo_name, *repo, *work_tree, *git_dir;
char *path, *dir, *display_repo = NULL;
int dest_exists, real_dest_exists = 0;
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ */
+ git_config(git_clone_config, NULL);
- path = get_repo_path(remote->url[0], &is_bundle);
- is_local = option_local != 0 && path && !is_bundle;
-+
-+ /* Detect if the remote repository is shallow */
-+ if (!access(mkpath("%s/shallow", path), F_OK)) {
-+ is_shallow = 1;
++ /*
++ * If option_shallow is specified from CLI option,
++ * ignore config_shallow from git_clone_config.
++ */
++ if (config_shallow != -1) {
++ reject_shallow = config_shallow;
+ }
-+
- if (is_local) {
- if (option_depth)
- warning(_("--depth is ignored in local clones; use file:// instead."));
++ if (option_shallow != -1) {
++ reject_shallow = option_shallow;
++ }
+ /*
+ * apply the remote name provided by --origin only after this second
+ * call to git_config, to ensure it overrides all config-based values.
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
- warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));
if (filter_options.choice)
warning(_("--filter is ignored in local clones; use file:// instead."));
-- if (!access(mkpath("%s/shallow", path), F_OK)) {
-+ if (is_shallow) {
+ if (!access(mkpath("%s/shallow", path), F_OK)) {
++ local_shallow = 1;
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ goto cleanup;
}
- if (option_local > 0 && !is_local)
- warning(_("--local is ignored"));
-+
-+ if (is_shallow) {
-+ int reject = 0;
-+
-+ /* If option_no_shallow is specified from CLI option,
-+ * ignore config_shallow from git_clone_config.
-+ */
-+
-+ if (config_shallow != -1) {
-+ reject = config_shallow;
-+ }
-+ if (option_no_shallow != -1) {
-+ reject = option_no_shallow;
-+ }
-+ if (reject) {
+
++ if (reject_shallow) {
++ if (local_shallow || is_repository_shallow(the_repository)) {
+ die(_("source repository is shallow, reject to clone."));
+ }
+ }
+
- transport->cloning = 1;
-
- transport_set_option(transport, TRANS_OPT_KEEP, "yes");
+ update_remote_refs(refs, mapped_refs, remote_head_points_at,
+ branch_top.buf, reflog_msg.buf, transport,
+ !is_local);
## t/t5606-clone-options.sh ##
+@@ t/t5606-clone-options.sh: GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
+ export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
+
+ . ./test-lib.sh
++. "$TEST_DIRECTORY"/lib-httpd.sh
++start_httpd
+
+ test_expect_success 'setup' '
+
@@ t/t5606-clone-options.sh: test_expect_success 'disallows --bare with --separate-git-dir' '
'
++test_expect_success 'fail to clone http shallow repository' '
++ git clone --depth=1 --no-local parent shallow-repo &&
++ git clone --bare --no-local shallow-repo "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" &&
++ test_must_fail git clone --reject-shallow $HTTPD_URL/smart/repo.git out 2>err &&
++ test_i18ngrep -e "source repository is shallow, reject to clone." err
++
++'
++
+test_expect_success 'fail to clone shallow repository' '
++ rm -rf shallow-repo &&
+ git clone --depth=1 --no-local parent shallow-repo &&
+ test_must_fail git clone --reject-shallow shallow-repo out 2>err &&
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
+'
+
-+test_expect_success 'clone.rejectshallow=false should succeed cloning' '
++test_expect_success 'clone.rejectshallow=false should succeed' '
+ rm -rf child &&
+ git clone --depth=1 --no-local . child &&
+ git -c clone.rejectshallow=false clone --no-local child out
+'
+
-+test_expect_success 'clone.rejectshallow=true should succeed cloning normal repo' '
++test_expect_success 'clone.rejectshallow=true should succeed with normal repo' '
+ rm -rf child out &&
+ git clone --no-local . child &&
+ git -c clone.rejectshallow=true clone --no-local child out
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
+test_expect_success 'option --reject-shallow override clone.rejectshallow' '
+ rm -rf child out &&
+ git clone --depth=1 --no-local . child &&
-+ test_must_fail git clone -c clone.rejectshallow=false --reject-shallow --no-local child out 2>err &&
++ test_must_fail git -c clone.rejectshallow=false clone --reject-shallow --no-local child out 2>err &&
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
+'
+
-+test_expect_success ' option --no-reject-shallow override clone.rejectshallow' '
++test_expect_success 'option --no-reject-shallow override clone.rejectshallow' '
+ rm -rf child &&
+ git clone --depth=1 --no-local . child &&
+ git -c clone.rejectshallow=true clone --no-reject-shallow --no-local child out
Documentation/config/clone.txt | 4 +++
Documentation/git-clone.txt | 7 ++++-
builtin/clone.c | 27 +++++++++++++++++++
t/t5606-clone-options.sh | 47 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 +++++++++++++++++++++++
5 files changed, 116 insertions(+), 1 deletion(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectshallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository. The+ 'clone.rejectshallow' configuration variable can be used to+ give the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1236,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+local_shallow=1;if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -1363,6 +1384,12 @@ int cmd_clone(int argc, const char **argv, const char *prefix)gotocleanup;}+if(reject_shallow){+if(local_shallow||is_repository_shallow(the_repository)){+die(_("source repository is shallow, reject to clone."));+}+}+update_remote_refs(refs,mapped_refs,remote_head_points_at,branch_top.buf,reflog_msg.buf,transport,!is_local);
@@ -45,6 +47,51 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'fail to clone http shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--bare--no-localshallow-repo"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should fail to clone''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed with normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=falseclone--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'option --no-reject-shallow override clone.rejectshallow''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectshallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository. The+ 'clone.rejectshallow' configuration variable can be used to+ give the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1234,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(reject_shallow)+die("source repository is shallow, reject to clone.");if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -45,6 +47,51 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'fail to clone http shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--bare--no-localshallow-repo"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should fail to clone''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed with normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=falseclone--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'option --no-reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.remote_shallow=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"
The name of the remote to create when cloning a repository. Defaults to
`origin`, and can be overridden by passing the `--origin` command-line
option to linkgit:git-clone[1].
+
+clone.rejectshallow::
+ Reject to clone a repository if it is a shallow one, can be overridden by
+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository.--no-checkout::
No checkout of HEAD is performed after the clone is complete.
+--[no-]reject-shallow::
+ Fail if the source repository is a shallow repository. The
+ 'clone.rejectshallow' configuration variable can be used to
+ give the default.
+
--bare::
Make a 'bare' Git repository. That is, instead of
creating `<directory>` and placing the administrative
*/
git_config(git_clone_config, NULL);
+ /*
+ * If option_shallow is specified from CLI option,
+ * ignore config_shallow from git_clone_config.
+ */
+ if (config_shallow != -1) {
+ reject_shallow = config_shallow;
+ }
+ if (option_shallow != -1) {
+ reject_shallow = option_shallow;
+ }
/*
* apply the remote name provided by --origin only after this second
* call to git_config, to ensure it overrides all config-based values.
if (filter_options.choice)
warning(_("--filter is ignored in local clones; use file:// instead."));
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
+ die("source repository is shallow, reject to clone.");
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
if (args->stateless_rpc)
packet_flush(fd[1]);
+
+ if (!args->deepen && args->remote_shallow)
+ die("source repository is shallow, reject to clone.");
+
I am not sure if we should apply this to non-protocol-v2.
quoted hunk
if (args->deepen)
setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
NULL);
* shallow. In v0, remote refs that reach these objects are
* rejected (unless --update-shallow is set); do the same.
*/
+ if (args->remote_shallow)
+ die("source repository is shallow, reject to clone.");
I just found that Johannes Schindelin wrote a document 14 year ago
in Documentation/technical/shallow.txt:
"There are some unfinished ends of the whole shallow business:
A special handling of a shallow upstream is needed. At some stage,
upload-pack has to check if it sends a shallow commit, and it should
send that information early (or fail, if the client does not support
shallow repositories). There is no support at all for this in this patch
series."
It seems that my patch can sovle his worry in some degree,
and maybe we could warn client in fetch-pack stage, if we don't
choose to reject shallow cloning.
if (args->remote_shallow)
die("source repository is shallow, reject to clone.");
else
warning("remote source repository is shallow.");
quoted hunk
prepare_shallow_info(si, shallows);
if (si->nr_ours || si->nr_theirs)
alternate_shallow_file =
* shallow. In v0, remote refs that reach these objects are
* rejected (unless --update-shallow is set); do the same.
*/
+ if (args->remote_shallow)
+ die("source repository is shallow, reject to clone.");
I just found that Johannes Schindelin wrote a document 14 year ago
in Documentation/technical/shallow.txt:
"There are some unfinished ends of the whole shallow business:
A special handling of a shallow upstream is needed. At some stage,
upload-pack has to check if it sends a shallow commit, and it should
send that information early (or fail, if the client does not support
shallow repositories). There is no support at all for this in this patch
series."
Oh wow, what a blast from the past.
I do agree that your patch is an improvement over the current situation.
Thanks,
Johannes
It seems that my patch can sovle his worry in some degree,
and maybe we could warn client in fetch-pack stage, if we don't
choose to reject shallow cloning.
if (args->remote_shallow)
die("source repository is shallow, reject to clone.");
else
warning("remote source repository is shallow.");
quoted
prepare_shallow_info(si, shallows);
if (si->nr_ours || si->nr_theirs)
alternate_shallow_file =
* shallow. In v0, remote refs that reach these objects are
* rejected (unless --update-shallow is set); do the same.
*/
+ if (args->remote_shallow)
+ die("source repository is shallow, reject to clone.");
I just found that Johannes Schindelin wrote a document 14 year ago
in Documentation/technical/shallow.txt:
"There are some unfinished ends of the whole shallow business:
A special handling of a shallow upstream is needed. At some stage,
upload-pack has to check if it sends a shallow commit, and it should
send that information early (or fail, if the client does not support
shallow repositories). There is no support at all for this in this patch
series."
Oh wow, what a blast from the past.
I do agree that your patch is an improvement over the current situation.
Thanks. Glad to hear the voice from you, hope I can get some suggestions
from you too, especially on the transport part.
Thanks,
Johannes
quoted
It seems that my patch can sovle his worry in some degree,
and maybe we could warn client in fetch-pack stage, if we don't
choose to reject shallow cloning.
if (args->remote_shallow)
die("source repository is shallow, reject to clone.");
else
warning("remote source repository is shallow.");
From: Li Linchao via GitGitGadget <hidden> Date: 2021-03-04 17:21:07
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Changes since v5:
* camelcase config variable
* warning client that source repo is shallow
* better support ssh:// and git:// protocol v1, v2
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v6
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v6
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v5:
1: 3f765e49e4a7 ! 1: 953122588ca8 builtin/clone.c: add --reject-shallow option
@@ Documentation/config/clone.txt: clone.defaultRemoteName::
`origin`, and can be overridden by passing the `--origin` command-line
option to linkgit:git-clone[1].
+
-+clone.rejectshallow::
++clone.rejectShallow::
+ Reject to clone a repository if it is a shallow one, can be overridden by
+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ Documentation/git-clone.txt: objects from the source repository into a pack in t
No checkout of HEAD is performed after the clone is complete.
+--[no-]reject-shallow::
-+ Fail if the source repository is a shallow repository. The
-+ 'clone.rejectshallow' configuration variable can be used to
++ Fail if the source repository is a shallow repository.
++ The 'clone.rejectShallow' configuration variable can be used to
+ give the default.
+
--bare::
@@ builtin/clone.c: static int git_clone_config(const char *k, const char *v, void
free(remote_name);
remote_name = xstrdup(v);
}
-+ if (!strcmp(k, "clone.rejectshallow")) {
++ if (!strcmp(k, "clone.rejectshallow"))
+ config_shallow = git_config_bool(k, v);
-+ }
++
return git_default_config(k, v, cb);
}
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ * If option_shallow is specified from CLI option,
+ * ignore config_shallow from git_clone_config.
+ */
-+ if (config_shallow != -1) {
++ if (config_shallow != -1)
+ reject_shallow = config_shallow;
-+ }
-+ if (option_shallow != -1) {
++
++ if (option_shallow != -1)
+ reject_shallow = option_shallow;
-+ }
++
/*
* apply the remote name provided by --origin only after this second
* call to git_config, to ensure it overrides all config-based values.
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
+ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ fetch-pack.c: static struct ref *do_fetch_pack(struct fetch_pack_args *args,
if (args->stateless_rpc)
packet_flush(fd[1]);
-+
-+ if (!args->deepen && args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
+
if (args->deepen)
setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
NULL);
+- else if (si->nr_ours || si->nr_theirs)
++ else if (si->nr_ours || si->nr_theirs) {
++ if (args->remote_shallow)
++ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
+ alternate_shallow_file = setup_temporary_shallow(si->shallow);
+- else
++ } else
+ alternate_shallow_file = NULL;
+ if (get_pack(args, fd, pack_lockfiles, NULL, sought, nr_sought,
+ &gitmodules_oids))
@@ fetch-pack.c: static void receive_shallow_info(struct fetch_pack_args *args,
- * shallow. In v0, remote refs that reach these objects are
* rejected (unless --update-shallow is set); do the same.
*/
-+ if (args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
prepare_shallow_info(si, shallows);
- if (si->nr_ours || si->nr_theirs)
+- if (si->nr_ours || si->nr_theirs)
++ if (si->nr_ours || si->nr_theirs) {
++ if (args->remote_shallow)
++ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
alternate_shallow_file =
+ setup_temporary_shallow(si->shallow);
+- else
++ } else
+ alternate_shallow_file = NULL;
+ } else {
+ alternate_shallow_file = NULL;
## fetch-pack.h ##
@@ fetch-pack.h: struct fetch_pack_args {
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
test_commit attributes .gitattributes "" &&
rm -rf child &&
- ## transport-helper.c ##
-@@ transport-helper.c: static const char *boolean_options[] = {
- TRANS_OPT_THIN,
- TRANS_OPT_KEEP,
- TRANS_OPT_FOLLOWTAGS,
-- TRANS_OPT_DEEPEN_RELATIVE
-+ TRANS_OPT_DEEPEN_RELATIVE,
-+ TRANS_OPT_REJECT_SHALLOW
- };
-
- static int strbuf_set_helper_option(struct helper_data *data,
-
## transport.c ##
@@ transport.c: static int set_git_option(struct git_transport_options *opts,
list_objects_filter_die_if_populated(&opts->filter_options);
@@ transport.h: void transport_check_allowed(const char *type);
/* Aggressively fetch annotated tags if possible */
#define TRANS_OPT_FOLLOWTAGS "followtags"
-+/* reject shallow repo transport */
++/* Reject shallow repo transport */
+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"
+
/* Accept refs that may update .git/shallow without --depth */
Documentation/config/clone.txt | 4 +++
Documentation/git-clone.txt | 7 ++++-
builtin/clone.c | 24 +++++++++++++++++
fetch-pack.c | 17 +++++++++---
fetch-pack.h | 1 +
t/t5606-clone-options.sh | 47 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 +++++++++++++++++++++++
transport.c | 4 +++
transport.h | 4 +++
9 files changed, 135 insertions(+), 5 deletions(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectShallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ give the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1234,10 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(reject_shallow)+die("source repository is shallow, reject to clone.");+else+warning("source repository is shallow.");if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -45,6 +47,51 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'fail to clone http shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--bare--no-localshallow-repo"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should fail to clone''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed with normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=falseclone--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'option --no-reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.remote_shallow=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* Reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"
PING.
Seems that this patch have been forgotten by everyone.
--------------
quoted hunk
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Changes since v5:
* camelcase config variable
* warning client that source repo is shallow
* better support ssh:// and git:// protocol v1, v2
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v6
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v6
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v5:
1: 3f765e49e4a7 ! 1: 953122588ca8 builtin/clone.c: add --reject-shallow option
@@ Documentation/config/clone.txt: clone.defaultRemoteName::
`origin`, and can be overridden by passing the `--origin` command-line
option to linkgit:git-clone[1].
+
-+clone.rejectshallow::
++clone.rejectShallow::
+ Reject to clone a repository if it is a shallow one, can be overridden by
+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ Documentation/git-clone.txt: objects from the source repository into a pack in t
No checkout of HEAD is performed after the clone is complete.
+--[no-]reject-shallow::
-+ Fail if the source repository is a shallow repository. The
-+ 'clone.rejectshallow' configuration variable can be used to
++ Fail if the source repository is a shallow repository.
++ The 'clone.rejectShallow' configuration variable can be used to
+ give the default.
+
--bare::
@@ builtin/clone.c: static int git_clone_config(const char *k, const char *v, void
free(remote_name);
remote_name = xstrdup(v);
}
-+ if (!strcmp(k, "clone.rejectshallow")) {
++ if (!strcmp(k, "clone.rejectshallow"))
+ config_shallow = git_config_bool(k, v);
-+ }
++
return git_default_config(k, v, cb);
}
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ * If option_shallow is specified from CLI option,
+ * ignore config_shallow from git_clone_config.
+ */
-+ if (config_shallow != -1) {
++ if (config_shallow != -1)
+ reject_shallow = config_shallow;
-+ }
-+ if (option_shallow != -1) {
++
++ if (option_shallow != -1)
+ reject_shallow = option_shallow;
-+ }
++
/*
* apply the remote name provided by --origin only after this second
* call to git_config, to ensure it overrides all config-based values.
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
+ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ fetch-pack.c: static struct ref *do_fetch_pack(struct fetch_pack_args *args,
if (args->stateless_rpc)
packet_flush(fd[1]);
-+
-+ if (!args->deepen && args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
+
if (args->deepen)
setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
NULL);
+- else if (si->nr_ours || si->nr_theirs)
++ else if (si->nr_ours || si->nr_theirs) {
++ if (args->remote_shallow)
++ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
+ alternate_shallow_file = setup_temporary_shallow(si->shallow);
+- else
++ } else
+ alternate_shallow_file = NULL;
+ if (get_pack(args, fd, pack_lockfiles, NULL, sought, nr_sought,
+ &gitmodules_oids))
@@ fetch-pack.c: static void receive_shallow_info(struct fetch_pack_args *args,
- * shallow. In v0, remote refs that reach these objects are
* rejected (unless --update-shallow is set); do the same.
*/
-+ if (args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
prepare_shallow_info(si, shallows);
- if (si->nr_ours || si->nr_theirs)
+- if (si->nr_ours || si->nr_theirs)
++ if (si->nr_ours || si->nr_theirs) {
++ if (args->remote_shallow)
++ die("source repository is shallow, reject to clone.");
++ else
++ warning("source repository is shallow.");
alternate_shallow_file =
+ setup_temporary_shallow(si->shallow);
+- else
++ } else
+ alternate_shallow_file = NULL;
+ } else {
+ alternate_shallow_file = NULL;
## fetch-pack.h ##
@@ fetch-pack.h: struct fetch_pack_args {
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
test_commit attributes .gitattributes "" &&
rm -rf child &&
- ## transport-helper.c ##
-@@ transport-helper.c: static const char *boolean_options[] = {
- TRANS_OPT_THIN,
- TRANS_OPT_KEEP,
- TRANS_OPT_FOLLOWTAGS,
-- TRANS_OPT_DEEPEN_RELATIVE
-+ TRANS_OPT_DEEPEN_RELATIVE,
-+ TRANS_OPT_REJECT_SHALLOW
- };
-
- static int strbuf_set_helper_option(struct helper_data *data,
-
## transport.c ##
@@ transport.c: static int set_git_option(struct git_transport_options *opts,
list_objects_filter_die_if_populated(&opts->filter_options);
@@ transport.h: void transport_check_allowed(const char *type);
/* Aggressively fetch annotated tags if possible */
#define TRANS_OPT_FOLLOWTAGS "followtags"
-+/* reject shallow repo transport */
++/* Reject shallow repo transport */
+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"
+
/* Accept refs that may update .git/shallow without --depth */
Documentation/config/clone.txt | 4 +++
Documentation/git-clone.txt | 7 ++++-
builtin/clone.c | 24 +++++++++++++++++
fetch-pack.c | 17 +++++++++---
fetch-pack.h | 1 +
t/t5606-clone-options.sh | 47 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 +++++++++++++++++++++++
transport.c | 4 +++
transport.h | 4 +++
9 files changed, 135 insertions(+), 5 deletions(-)
The name of the remote to create when cloning a repository. Defaults to
`origin`, and can be overridden by passing the `--origin` command-line
option to linkgit:git-clone[1].
+
+clone.rejectShallow::
+ Reject to clone a repository if it is a shallow one, can be overridden by
+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository.--no-checkout::
No checkout of HEAD is performed after the clone is complete.
+--[no-]reject-shallow::
+ Fail if the source repository is a shallow repository.
+ The 'clone.rejectShallow' configuration variable can be used to
+ give the default.
+
--bare::
Make a 'bare' Git repository. That is, instead of
creating `<directory>` and placing the administrative
*/
git_config(git_clone_config, NULL);
+ /*
+ * If option_shallow is specified from CLI option,
+ * ignore config_shallow from git_clone_config.
+ */
+ if (config_shallow != -1)
+ reject_shallow = config_shallow;
+
+ if (option_shallow != -1)
+ reject_shallow = option_shallow;
+
/*
* apply the remote name provided by --origin only after this second
* call to git_config, to ensure it overrides all config-based values.
if (filter_options.choice)
warning(_("--filter is ignored in local clones; use file:// instead."));
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
+ die("source repository is shallow, reject to clone.");
+ else
+ warning("source repository is shallow.");
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
From: Li Linchao via GitGitGadget <hidden> Date: 2021-03-25 11:10:18
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
Reviewed-by: Derrick Stolee <redacted>
Reviewed-by: Junio C Hamano<redacted>
Reviewed-by: Johannes Schindelin <redacted>
Reviewed-by: Jonathan Tan<redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Changes since v5:
* camelcase config variable
* warning client that source repo is shallow
* better support ssh:// and git:// protocol v1, v2
Changes since v6:
* use _() for warning/die statement
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v7
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v7
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v6:
1: 953122588ca8 ! 1: b957b77bfd79 builtin/clone.c: add --reject-shallow option
@@ Commit message
Signed-off-by: lilinchao [off-list ref]
+ Reviewed-by: Derrick Stolee [off-list ref]
+ Reviewed-by: Junio C Hamano[off-list ref]
+ Reviewed-by: Johannes Schindelin [off-list ref]
+ Reviewed-by: Jonathan Tan[off-list ref]
+
## Documentation/config/clone.txt ##
@@ Documentation/config/clone.txt: clone.defaultRemoteName::
The name of the remote to create when cloning a repository. Defaults to
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
warning(_("--filter is ignored in local clones; use file:// instead."));
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
-+ die("source repository is shallow, reject to clone.");
++ die(_("source repository is shallow, reject to clone."));
+ else
-+ warning("source repository is shallow.");
++ warning(_("source repository is shallow."));
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
## fetch-pack.c ##
@@ fetch-pack.c: static struct ref *do_fetch_pack(struct fetch_pack_args *args,
-
- if (args->stateless_rpc)
- packet_flush(fd[1]);
-+
if (args->deepen)
setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
NULL);
- else if (si->nr_ours || si->nr_theirs)
+ else if (si->nr_ours || si->nr_theirs) {
+ if (args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
++ die(_("source repository is shallow, reject to clone."));
+ else
-+ warning("source repository is shallow.");
++ warning(_("source repository is shallow."));
alternate_shallow_file = setup_temporary_shallow(si->shallow);
- else
+ } else
@@ fetch-pack.c: static void receive_shallow_info(struct fetch_pack_args *args,
- if (si->nr_ours || si->nr_theirs)
+ if (si->nr_ours || si->nr_theirs) {
+ if (args->remote_shallow)
-+ die("source repository is shallow, reject to clone.");
++ die(_("source repository is shallow, reject to clone."));
+ else
-+ warning("source repository is shallow.");
++ warning(_("source repository is shallow."));
alternate_shallow_file =
setup_temporary_shallow(si->shallow);
- else
Documentation/config/clone.txt | 4 +++
Documentation/git-clone.txt | 7 ++++-
builtin/clone.c | 24 +++++++++++++++++
fetch-pack.c | 16 +++++++++---
fetch-pack.h | 1 +
t/t5606-clone-options.sh | 47 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 +++++++++++++++++++++++
transport.c | 4 +++
transport.h | 4 +++
9 files changed, 134 insertions(+), 5 deletions(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectShallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ give the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1234,10 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(reject_shallow)+die(_("source repository is shallow, reject to clone."));+else+warning(_("source repository is shallow."));if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -45,6 +47,51 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'fail to clone http shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--bare--no-localshallow-repo"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'fail to clone non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should fail to clone''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed with normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=falseclone--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'option --no-reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.remote_shallow=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* Reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"
From: Li Linchao via GitGitGadget <hidden> Date: 2021-03-29 10:20:13
From: lilinchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Signed-off-by: lilinchao <redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Changes since v5:
* camelcase config variable
* warning client that source repo is shallow
* better support ssh:// and git:// protocol v1, v2
Changes since v6:
* use _() for warning/die statement
Signed-off-by: lilinchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v8
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v8
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v7:
1: b957b77bfd79 ! 1: 83a724f6d771 builtin/clone.c: add --reject-shallow option
@@ Commit message
Signed-off-by: lilinchao [off-list ref]
- Reviewed-by: Derrick Stolee [off-list ref]
- Reviewed-by: Junio C Hamano[off-list ref]
- Reviewed-by: Johannes Schindelin [off-list ref]
- Reviewed-by: Jonathan Tan[off-list ref]
-
## Documentation/config/clone.txt ##
@@ Documentation/config/clone.txt: clone.defaultRemoteName::
The name of the remote to create when cloning a repository. Defaults to
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
if (!access(mkpath("%s/shallow", path), F_OK)) {
+ if (reject_shallow)
+ die(_("source repository is shallow, reject to clone."));
-+ else
-+ warning(_("source repository is shallow."));
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
is_local = 0;
@@ fetch-pack.c: static struct ref *do_fetch_pack(struct fetch_pack_args *args,
+ else if (si->nr_ours || si->nr_theirs) {
+ if (args->remote_shallow)
+ die(_("source repository is shallow, reject to clone."));
-+ else
-+ warning(_("source repository is shallow."));
alternate_shallow_file = setup_temporary_shallow(si->shallow);
- else
+ } else
@@ fetch-pack.c: static void receive_shallow_info(struct fetch_pack_args *args,
+ if (si->nr_ours || si->nr_theirs) {
+ if (args->remote_shallow)
+ die(_("source repository is shallow, reject to clone."));
-+ else
-+ warning(_("source repository is shallow."));
alternate_shallow_file =
setup_temporary_shallow(si->shallow);
- else
@@ t/t5606-clone-options.sh: test_expect_success 'disallows --bare with --separate-
'
-+test_expect_success 'fail to clone http shallow repository' '
++test_expect_success 'reject cloning http shallow repository' '
+ git clone --depth=1 --no-local parent shallow-repo &&
+ git clone --bare --no-local shallow-repo "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" &&
+ test_must_fail git clone --reject-shallow $HTTPD_URL/smart/repo.git out 2>err &&
@@ t/t5606-clone-options.sh: test_expect_success 'disallows --bare with --separate-
+
+'
+
-+test_expect_success 'fail to clone shallow repository' '
++test_expect_success 'reject cloning shallow repository' '
+ rm -rf shallow-repo &&
+ git clone --depth=1 --no-local parent shallow-repo &&
+ test_must_fail git clone --reject-shallow shallow-repo out 2>err &&
@@ t/t5606-clone-options.sh: test_expect_success 'disallows --bare with --separate-
+
+'
+
-+test_expect_success 'fail to clone non-local shallow repository' '
++test_expect_success 'reject cloning non-local shallow repository' '
+ rm -rf shallow-repo &&
+ git clone --depth=1 --no-local parent shallow-repo &&
+ test_must_fail git clone --reject-shallow --no-local shallow-repo out 2>err &&
@@ t/t5611-clone-config.sh: test_expect_success 'clone -c remote.<remote>.fetch=<re
test_cmp expect actual
'
-+test_expect_success 'clone.rejectshallow=true should fail to clone' '
++test_expect_success 'clone.rejectshallow=true should reject cloning' '
+ rm -rf child &&
+ git clone --depth=1 --no-local . child &&
+ test_must_fail git -c clone.rejectshallow=true clone --no-local child out 2>err &&
Documentation/config/clone.txt | 4 +++
Documentation/git-clone.txt | 7 ++++-
builtin/clone.c | 22 ++++++++++++++++
fetch-pack.c | 12 ++++++---
fetch-pack.h | 1 +
t/t5606-clone-options.sh | 47 ++++++++++++++++++++++++++++++++++
t/t5611-clone-config.sh | 32 +++++++++++++++++++++++
transport.c | 4 +++
transport.h | 4 +++
9 files changed, 128 insertions(+), 5 deletions(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectShallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ give the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1234,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(reject_shallow)+die(_("source repository is shallow, reject to clone."));if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -45,6 +47,51 @@ test_expect_success 'disallows --bare with --separate-git-dir' ''+test_expect_success'reject cloning http shallow repository''+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--bare--no-localshallow-repo"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'reject cloning shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallowshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'reject cloning non-local shallow repository''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+test_must_failgitclone--reject-shallow--no-localshallow-repoout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err++'++test_expect_success'clone shallow repository with --no-reject-shallow''+rm-rfshallow-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitclone--no-reject-shallow--no-localshallow-repoclone-repo++'++test_expect_success'clone normal repository with --reject-shallow''+rm-rfclone-repo&&+gitclone--no-localparentnormal-repo&&+gitclone--reject-shallow--no-localnormal-repoclone-repo++'++test_expect_success'unspecified any configs or options''+rm-rfshallow-repoclone-repo&&+gitclone--depth=1--no-localparentshallow-repo&&+gitcloneshallow-repoclone-repo++'+ test_expect_success'uses "origin" for default remote name''gitcloneparentclone-default-origin&&
@@ -95,6 +95,38 @@ test_expect_success 'clone -c remote.<remote>.fetch=<refspec> --origin=<name>' 'test_cmpexpectactual'+test_expect_success'clone.rejectshallow=true should reject cloning''+rm-rfchild&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=trueclone--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'clone.rejectshallow=false should succeed''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=falseclone--no-localchildout+'++test_expect_success'clone.rejectshallow=true should succeed with normal repo''+rm-rfchildout&&+gitclone--no-local.child&&+git-cclone.rejectshallow=trueclone--no-localchildout+'++test_expect_success'option --reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+test_must_failgit-cclone.rejectshallow=falseclone--reject-shallow--no-localchildout2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err+'++test_expect_success'option --no-reject-shallow override clone.rejectshallow''+rm-rfchildout&&+gitclone--depth=1--no-local.child&&+git-cclone.rejectshallow=trueclone--no-reject-shallow--no-localchildout+'+ test_expect_successMINGW'clone -c core.hideDotFiles''test_commitattributes.gitattributes""&&rm-rfchild&&
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.remote_shallow=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* Reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"
From: Johannes Schindelin <hidden> Date: 2021-03-30 09:55:43
Hi,
On Mon, 29 Mar 2021, Li Linchao via GitGitGadget wrote:
From: lilinchao <redacted>
I see "Li Linchao" in the email, but "lilinchao" in the author
information. Maybe you want to align them? Or maybe even use Unicode to
write your non-Latinized name?
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, users should have the option to
refuse to clone this kind of repository, and may want to exit the
process immediately without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, but as the unshallow cloning's depth
is INFINITY, we can't know exactly the minimun 'x' value that can
satisfy the minimum integrity, so we can't pass 'x' value to --depth,
and expect this can obtain a complete history of a repository.
In other scenarios, if we have an API that allow us to import external
repository, and then perform various operations on the repo.
But if the imported is a shallow one(which is actually possible), it
will affect the subsequent operations. So we can choose to refuse to
clone, and let's just import a normal repository.
This patch offers a new option '--reject-shallow' that can reject to
clone a shallow repository.
Good.
I like most of the patch, and will only point out a couple of things that
I think can be improved even further.
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ give the default.
I am not a native speaker, either, but I believe that it would "roll off
the tongue" a bit better to say "to specify the default".
quoted hunk
+
--bare::
Make a 'bare' Git repository. That is, instead of
creating `<directory>` and placing the administrative
I would much prefer those variable names to include an indicator that this
is about _rejecting_ shallow clones. I.e. `option_reject_shallow`.
Also, I think that we can do with just a single `option_reject_shallow`
(we do not even need that `reject_shallow` variable in `cmd_clone()`):
- in `git_clone_config()`, only override it if it is still unspecified:
if (!strcmp(k, "clone.rejectshallow") && option_reject_shallow < 0)
option_reject_shallow = git_config_bool(k,v);
- in `cmd_clone()`, test for a _positive_ value:
if (option_reject_shallow > 0)
die(_("source repository is shallow, reject to clone."));
and
if (option_reject_shallow > 0)
transport_set_option(transport, TRANS_OPT_REJECT_SHALLOW, "1");
One thing to note (in the commit message, would be my preference) is that
`cmd_clone()` is _particular_ in that it runs `git_config()` _twice_. Once
before the command-line options are parsed, and once after the new Git
repository has been initialized. Note that my suggestion still works with
that: if either the original config, or the new config set
`clone.rejectShallow`, it is picked up correctly, with the latter
overriding the former if both configs want to set it.
Even as a non-casual reader, this name `remote_shallow` leads me to assume
incorrect things. This option is not about wanting a remote shallow
repository, it is about rejecting a remote shallow repository.
Please name this attribute `reject_shallow` instead of `remote_shallow`.
That will prevent future puzzlement.
quoted hunk
+ die(_("source repository is shallow, reject to clone."));
alternate_shallow_file = setup_temporary_shallow(si->shallow);
- else
+ } else
alternate_shallow_file = NULL;
if (get_pack(args, fd, pack_lockfiles, NULL, sought, nr_sought,
&gitmodules_oids))
[...]
That's not good. What happens if there is no `httpd`? Then the rest of the
tests are either skipped, or if `GIT_TEST_HTTPD` is set to `true`, we
fail. The failure is intentional, but the skipping is not. There are many
tests in t5606 that do not require a running HTTP daemon, and we should
not skip them (for example, in our CI runs, there are quite a few jobs
that run without any working `httpd`).
A much better alternative, I think, would be to move those new test cases
that require `httpd` to be running to t5601 (which _already_ calls
`start_httpd`, near the end, so as to not skip any tests that do not
require `httpd`).
Should this line not come immediately after the bare clone into
<DOCUMENT_ROOT>/repo.git? Or even better, as a `test_when_finished`
command.
And maybe you want to extract this preparatory step into its own test
case:
test_expect_success 'set up shallow http repository' '
test_when_finished "rm -rf shallow-repo" &&
git clone --depth=1 --no-local parent shallow-repo &&
git clone --bare --no-local shallow-repo "$HTTPD_DOCUMENT_ROOT_PATH/repo.git"
'
+ git clone --depth=1 --no-local parent shallow-repo &&
+ test_must_fail git clone --reject-shallow shallow-repo out 2>err &&
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
+
Please remove the extra empty line. (This goes for at least a couple test
cases added by this patch.)
+'
This test case does not require `start_httpd`, and should therefore come
before the test cases that do require it (actually, it should come before
the `start_httpd` call, even).
Hmm. Reading through three test cases that all create `shallow-repo` in
the same way, I wonder whether we should not simply set it up once, and
then not even bother removing it. I think that would simplify not only the
patch, it would also simplify debugging later on.
Having read through these test cases, I think they can be simplified by
- first setting up `shallow-repo`
- then testing in the same test case whether `--reject-shallow` fails and
`--no-reject-shallow` succeeds, without `--no-local`
- then testing the same _with_ `--no-local`
These can go to t5606, no problem.
Then, in t5601, after the `start_httpd` call, add a single test case that
- sets up the shallow clone _directly_, i.e.
git clone --bare --no-local --depth=1 parent \
"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"
- verifies that `--reject-shallow` fails as expected, and
- verifies that `--no-reject-shallow` works as expected.
In the following, this shallow repository is needed a couple of times.
Better set it up once, in a dedicated `set up shallow repository` test
case.
And `shallow-repo` would probably make for a much better name than
`child`.
+ test_must_fail git -c clone.rejectshallow=true clone --no-local child out 2>err &&
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
+'
+
+test_expect_success 'clone.rejectshallow=false should succeed' '
+ rm -rf child out &&
+ git clone --depth=1 --no-local . child &&
+ git -c clone.rejectshallow=false clone --no-local child out
+'
These two can be combined (and should, if you ask me, to simplify things).
+
+test_expect_success 'clone.rejectshallow=true should succeed with normal repo' '
+ rm -rf child out &&
+ git clone --no-local . child &&
+ git -c clone.rejectshallow=true clone --no-local child out
+'
+
+test_expect_success 'option --reject-shallow override clone.rejectshallow' '
+ rm -rf child out &&
+ git clone --depth=1 --no-local . child &&
+ test_must_fail git -c clone.rejectshallow=false clone --reject-shallow --no-local child out 2>err &&
+ test_i18ngrep -e "source repository is shallow, reject to clone." err
+'
+
+test_expect_success 'option --no-reject-shallow override clone.rejectshallow' '
+ rm -rf child out &&
+ git clone --depth=1 --no-local . child &&
+ git -c clone.rejectshallow=true clone --no-reject-shallow --no-local child out
+'
+
Personally, I think this is overkill. What I would do is to have a single
test case that verifies that
- `clone.rejectShallow=true` fails as expected,
- `clone.rejectShallow=false [...] --reject-shallow` fails as expected, and
- `clone.rejectShallow=false` succeeds.
If we do this, we do not even need a preparatory test case setting up the
shallow repository.
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;
I see that this is the established pattern (I am so grateful that I have
https://github.com/gitgitgadget/git/pull/865/files to look at the context,
something with which a pure mail-only patch contribution would not bless
me!), that those Boolean options are `NULL` vs non-`NULL`. So while you
pass `"1"` as the `value` parameter to `set_git_option()`, the parameter
`"0"` would _enable that option just the same_, you would have to pass
`NULL` to turn it off. I find that highly unintuitive, but that's not the
fault of your patch. The pattern is established, and you did the right
thing by following it.
+ return 0;
}
return 1;
}
As I said, the rest of the patch looks good to me. With the few
suggestions I offered, I would be totally fine with this patch entering
`next`.
Thank you,
Dscho
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectShallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ specify the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1222,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(option_reject_shallow>0)+die(_("source repository is shallow, reject to clone."));if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -759,6 +759,15 @@ test_expect_success 'partial clone using HTTP' 'partial_clone"$HTTPD_DOCUMENT_ROOT_PATH/server""$HTTPD_URL/smart/server"'+test_expect_success'reject cloning shallow repository using HTTP''+test_when_finished"rm -rf repo"&&+gitclone--bare--no-local--depth=1src"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitrepo2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err&&++gitclone--no-reject-shallow$HTTPD_URL/smart/repo.gitrepo+'+# DO NOT add non-httpd-specific tests here, because the last part of this# test script is only executed when httpd is available and enabled.
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.reject_shallow_remote=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* Reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"
From: Li Linchao via GitGitGadget <hidden> Date: 2021-04-01 10:47:42
From: Li Linchao <redacted>
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
until they download it to local, we may want to refuse to clone
this kind of repository, without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
deep history they can fetch, as the unshallow cloning's depth is
INFINITY, we might start with depth x, and the source may be deep
enough to give us x right now, but we may want to deepen more than
they can offer, and such a user would want to be able to say
"I want depth=x now, but make sure they are not shallow".
it's hard to find such a x value to make sure they are not shallow.
Teach '--reject-shallow' option to "git clone" to abort as
soon as we find out that we are cloning from a shallow
repository.
Signed-off-by: Li Linchao <redacted>
---
builtin/clone.c: add --reject-shallow option
Changes since v1:
* Rename --no-shallow to --reject-shallow
* Enable to reject a non-local clone
* Enable --[no-]reject-shallow from CLI override configuration.
* Add more testcases.
* Reword commit messages and relative documentation.
Changes since v3:
* Add support to reject clone shallow repo over https protocol
* Add testcase to reject clone shallow repo over https:// transport
* Reword commit messages and relative documentation according
suggestions from Junio.
Changes since v5:
* camelcase config variable
* warning client that source repo is shallow
* better support ssh:// and git:// protocol v1, v2
Changes since v6:
* use _() for warning/die statement
Changes since v7:
* Clear reviewed-by trailer
* Drop warning() statement
* Reword a few test titles
Changes since v8:
* Use single variable for option and config
* Rename remote_shallow to reject_shallow_remote
* Simplify test cases
Changes since v9:
* Reword commit message
* Use option_reject_shallow and config_reject_shallow
Signed-off-by: Li Linchao lilinchao@oschina.cn
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-865%2FCactusinhand%2Fgit-clone-options-v10
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-865/Cactusinhand/git-clone-options-v10
Pull-Request: https://github.com/gitgitgadget/git/pull/865
Range-diff vs v9:
1: 11043a2344dd ! 1: cacda5a6af07 builtin/clone.c: add --reject-shallow option
@@
## Metadata ##
-Author: lilinchao [off-list ref]
+Author: Li Linchao [off-list ref]
## Commit message ##
builtin/clone.c: add --reject-shallow option
@@ Commit message
In some scenarios, users may want more history than the repository
offered for cloning, which happens to be a shallow repository, can
give them. But because users don't know it is a shallow repository
- until they download it to local, users should have the option to
- refuse to clone this kind of repository, and may want to exit the
- process immediately without creating any unnecessary files.
+ until they download it to local, we may want to refuse to clone
+ this kind of repository, without creating any unnecessary files.
Althought there is an option '--depth=x' for users to decide how
- deep history they can fetch, but as the unshallow cloning's depth
- is INFINITY, we can't know exactly the minimun 'x' value that can
- satisfy the minimum integrity, so we can't pass 'x' value to --depth,
- and expect this can obtain a complete history of a repository.
+ deep history they can fetch, as the unshallow cloning's depth is
+ INFINITY, we might start with depth x, and the source may be deep
+ enough to give us x right now, but we may want to deepen more than
+ they can offer, and such a user would want to be able to say
+ "I want depth=x now, but make sure they are not shallow".
+ it's hard to find such a x value to make sure they are not shallow.
- In other scenarios, if we have an API that allow us to import external
- repository, and then perform various operations on the repo.
- But if the imported is a shallow one(which is actually possible), it
- will affect the subsequent operations. So we can choose to refuse to
- clone, and let's just import a normal repository.
-
- This patch offers a new option '--reject-shallow' that can reject to
- clone a shallow repository.
+ Teach '--reject-shallow' option to "git clone" to abort as
+ soon as we find out that we are cloning from a shallow
+ repository.
Signed-off-by: Li Linchao [off-list ref]
@@ builtin/clone.c: static int option_no_checkout, option_bare, option_mirror, opti
static int option_no_tags;
static int option_shallow_submodules;
+static int option_reject_shallow = -1; /* unspecified */
++static int config_reject_shallow = -1; /* unspecified */
static int deepen;
static char *option_template, *option_depth, *option_since;
static char *option_origin = NULL;
@@ builtin/clone.c: static int git_clone_config(const char *k, const char *v, void
free(remote_name);
remote_name = xstrdup(v);
}
-+ if (!strcmp(k, "clone.rejectshallow") && option_reject_shallow < 0)
-+ option_reject_shallow = git_config_bool(k, v);
++ if (!strcmp(k, "clone.rejectshallow"))
++ config_reject_shallow = git_config_bool(k, v);
+
return git_default_config(k, v, cb);
}
+@@ builtin/clone.c: static int path_exists(const char *path)
+ int cmd_clone(int argc, const char **argv, const char *prefix)
+ {
+ int is_bundle = 0, is_local;
++ int reject_shallow = 0;
+ const char *repo_name, *repo, *work_tree, *git_dir;
+ char *path, *dir, *display_repo = NULL;
+ int dest_exists, real_dest_exists = 0;
+@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
+ */
+ git_config(git_clone_config, NULL);
+
++ /*
++ * If option_reject_shallow is specified from CLI option,
++ * ignore config_reject_shallow from git_clone_config.
++ */
++ if (config_reject_shallow != -1)
++ reject_shallow = config_reject_shallow;
++ if (option_reject_shallow != -1)
++ reject_shallow = option_reject_shallow;
++
+ /*
+ * apply the remote name provided by --origin only after this second
+ * call to git_config, to ensure it overrides all config-based values.
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
if (filter_options.choice)
warning(_("--filter is ignored in local clones; use file:// instead."));
if (!access(mkpath("%s/shallow", path), F_OK)) {
-+ if (option_reject_shallow > 0)
++ if (reject_shallow)
+ die(_("source repository is shallow, reject to clone."));
if (option_local > 0)
warning(_("source repository is shallow, ignoring --local"));
@@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
transport_set_option(transport, TRANS_OPT_KEEP, "yes");
-+ if (option_reject_shallow > 0)
++ if (reject_shallow)
+ transport_set_option(transport, TRANS_OPT_REJECT_SHALLOW, "1");
if (option_depth)
transport_set_option(transport, TRANS_OPT_DEPTH,
Documentation/config/clone.txt | 4 ++++
Documentation/git-clone.txt | 7 ++++++-
builtin/clone.c | 21 +++++++++++++++++++++
fetch-pack.c | 12 ++++++++----
fetch-pack.h | 1 +
t/t5601-clone.sh | 9 +++++++++
t/t5606-clone-options.sh | 27 ++++++++++++++++++++++++++-
t/t5611-clone-config.sh | 25 +++++++++++++++++++++++++
transport.c | 4 ++++
transport.h | 4 ++++
10 files changed, 108 insertions(+), 6 deletions(-)
@@ -2,3 +2,7 @@ clone.defaultRemoteName:: The name of the remote to create when cloning a repository. Defaults to `origin`, and can be overridden by passing the `--origin` command-line option to linkgit:git-clone[1].++clone.rejectShallow::+ Reject to clone a repository if it is a shallow one, can be overridden by+ passing option `--reject-shallow` in command line. See linkgit:git-clone[1]
@@ -149,6 +149,11 @@ objects from the source repository into a pack in the cloned repository. --no-checkout:: No checkout of HEAD is performed after the clone is complete.+--[no-]reject-shallow::+ Fail if the source repository is a shallow repository.+ The 'clone.rejectShallow' configuration variable can be used to+ specify the default.+ --bare:: Make a 'bare' Git repository. That is, instead of creating `<directory>` and placing the administrative
@@ -1216,6 +1233,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)if(filter_options.choice)warning(_("--filter is ignored in local clones; use file:// instead."));if(!access(mkpath("%s/shallow",path),F_OK)){+if(reject_shallow)+die(_("source repository is shallow, reject to clone."));if(option_local>0)warning(_("source repository is shallow, ignoring --local"));is_local=0;
@@ -759,6 +759,15 @@ test_expect_success 'partial clone using HTTP' 'partial_clone"$HTTPD_DOCUMENT_ROOT_PATH/server""$HTTPD_URL/smart/server"'+test_expect_success'reject cloning shallow repository using HTTP''+test_when_finished"rm -rf repo"&&+gitclone--bare--no-local--depth=1src"$HTTPD_DOCUMENT_ROOT_PATH/repo.git"&&+test_must_failgitclone--reject-shallow$HTTPD_URL/smart/repo.gitrepo2>err&&+test_i18ngrep-e"source repository is shallow, reject to clone."err&&++gitclone--no-reject-shallow$HTTPD_URL/smart/repo.gitrepo+'+# DO NOT add non-httpd-specific tests here, because the last part of this# test script is only executed when httpd is available and enabled.
@@ -236,6 +236,9 @@ static int set_git_option(struct git_transport_options *opts,list_objects_filter_die_if_populated(&opts->filter_options);parse_list_objects_filter(&opts->filter_options,value);return0;+}elseif(!strcmp(name,TRANS_OPT_REJECT_SHALLOW)){+opts->reject_shallow=!!value;+return0;}return1;}
@@ -370,6 +373,7 @@ static int fetch_refs_via_pack(struct transport *transport,args.stateless_rpc=transport->stateless_rpc;args.server_options=transport->server_options;args.negotiation_tips=data->options.negotiation_tips;+args.reject_shallow_remote=transport->smart_options->reject_shallow;if(!data->got_remote_heads){inti;
@@ -14,6 +14,7 @@ struct git_transport_options {unsignedcheck_self_contained_and_connected:1;unsignedself_contained_and_connected:1;unsignedupdate_shallow:1;+unsignedreject_shallow:1;unsigneddeepen_relative:1;/* see documentation of corresponding flag in fetch-pack.h */
@@ -194,6 +195,9 @@ void transport_check_allowed(const char *type);/* Aggressively fetch annotated tags if possible */#define TRANS_OPT_FOLLOWTAGS "followtags"+/* Reject shallow repo transport */+#define TRANS_OPT_REJECT_SHALLOW "rejectshallow"+/* Accept refs that may update .git/shallow without --depth */#define TRANS_OPT_UPDATE_SHALLOW "updateshallow"