From patchwork Fri Feb 5 04:58:31 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Tan X-Patchwork-Id: 12069287 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.2 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BC186C433DB for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 77F6464E22 for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231200AbhBEE72 (ORCPT ); Thu, 4 Feb 2021 23:59:28 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43764 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231168AbhBEE7U (ORCPT ); Thu, 4 Feb 2021 23:59:20 -0500 Received: from mail-pf1-x44a.google.com (mail-pf1-x44a.google.com [IPv6:2607:f8b0:4864:20::44a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E4A9AC06178A for ; Thu, 4 Feb 2021 20:58:39 -0800 (PST) Received: by mail-pf1-x44a.google.com with SMTP id t16so4048492pfh.22 for ; Thu, 04 Feb 2021 20:58:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=44iXLyYlG6pFAz+0dCRTOvE38Y784hK0/VnCluqyfYw=; b=blqxI74WqxFrt37grLQHfvn+wgBN/0i6GfET8dOYx0tgoq+1xukfEuYpcjT35RN9x8 62ERb92ZFQVBxHPeP2feVbLxlTQKy6Fg6LERD/xfuzvqK3Tg5fV98voziLdvDSsmecih xBjjEZidA9AiwvSQOi+d8/2g9R7CcODp30Mpp18BLO0CJPzD2MznypkYYl0mLYtTXLQj L0/CVw0lkYgin1/1oHKa82nWFav7ZLCQyqq6EJK73lmrC1Dj3ceCytZnBj1molWVa5j8 na6ajPaImRsjOfxHzT39W3Hwe3oFpknQLc2UQ6k5q7J/lEO1i1UOm6qqtJlIR7yaX4ha H3jQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=44iXLyYlG6pFAz+0dCRTOvE38Y784hK0/VnCluqyfYw=; b=cxpqpusYkVBUAvNOSUJEABAgGxfUhpYh+qBvj6s/FDu/JHV69qR8uSlDADuxyWxmxG i7F3fJ23KA9Q6wPyuQajT2IV7EQyineQUIQO0gXJ+2Bm2go7HM6UFp3eTxzJFT51u2zG 4bd/TQLTjVHqN2pC1oOriZRdQ40EnQX1W2C3i2GuhPiCDRnua49qHb99rUHBFgDkiq+E /+lV9+mBRTRyLN1pNgg6hjV/v3r9elQWH8n6yIhvPGLdyesUhtrS7+/7DoLvSFwF3hm8 zuZQ+I7RaI8Z1j40PRLBLUE0TAsrs/ezcS2/9bf7nULatteXbrXp17BAjnuowSnwZAv0 iamw== X-Gm-Message-State: AOAM532pyT5IZCoY8DPMuGqUNXEa5fq/kT/bWR6U3H9MCU7jETxJLpLY IBlMYR5yFrfQ4Rt04K1A6H2uy9xrc0B5UQWtfQAmFdDoqkjOEAK12Pq/4SmND8KiNthfwbg1+7d xsmKNFyaLgZEh4Vth9IF9fBxi9bul3wBnvU4G9eFNb69gpq/Qgne9SgRk6WBAwzOtL/3oJ4K/pD RF X-Google-Smtp-Source: ABdhPJzQGEOxSH5O75J6DjepAyfDMo8JmMjJjClfta6RFQYtxrQUO2krpEd+fEXWMB7Hj63vcceU5KkHtGjCw5zCEctq Sender: "jonathantanmy via sendgmr" X-Received: from twelve4.c.googlers.com ([fda3:e722:ac3:10:24:72f4:c0a8:437a]) (user=jonathantanmy job=sendgmr) by 2002:a17:902:9690:b029:e1:5a03:87b5 with SMTP id n16-20020a1709029690b02900e15a0387b5mr2377120plp.39.1612501119306; Thu, 04 Feb 2021 20:58:39 -0800 (PST) Date: Thu, 4 Feb 2021 20:58:31 -0800 In-Reply-To: Message-Id: <2d3507536924346637bb138af5a3562ce8f2abc2.1612493309.git.jonathantanmy@google.com> Mime-Version: 1.0 References: <20201208013121.677494-1-jonathantanmy@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH v7 1/3] ls-refs: report unborn targets of symrefs From: Jonathan Tan To: git@vger.kernel.org Cc: Jonathan Tan , gitster@pobox.com Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org When cloning, we choose the default branch based on the remote HEAD. But if there is no remote HEAD reported (which could happen if the target of the remote HEAD is unborn), we'll fall back to using our local init.defaultBranch. Traditionally this hasn't been a big deal, because most repos used "master" as the default. But these days it is likely to cause confusion if the server and client implementations choose different values (e.g., if the remote started with "main", we may choose "master" locally, create commits there, and then the user is surprised when they push to "master" and not "main"). To solve this, the remote needs to communicate the target of the HEAD symref, even if it is unborn, and "git clone" needs to use this information. Currently, symrefs that have unborn targets (such as in this case) are not communicated by the protocol. Teach Git to advertise and support the "unborn" feature in "ls-refs" (by default, this is advertised, but server administrators may turn this off through the lsrefs.unborn config). This feature indicates that "ls-refs" supports the "unborn" argument; when it is specified, "ls-refs" will send the HEAD symref with the name of its unborn target. This change is only for protocol v2. A similar change for protocol v0 would require independent protocol design (there being no analogous position to signal support for "unborn") and client-side plumbing of the data required, so the scope of this patch set is limited to protocol v2. The client side will be updated to use this in a subsequent commit. Signed-off-by: Jonathan Tan Signed-off-by: Junio C Hamano --- Documentation/config.txt | 2 + Documentation/config/lsrefs.txt | 9 +++ Documentation/technical/protocol-v2.txt | 11 +++- ls-refs.c | 74 ++++++++++++++++++++++++- ls-refs.h | 1 + serve.c | 2 +- t/t5701-git-serve.sh | 2 +- 7 files changed, 95 insertions(+), 6 deletions(-) create mode 100644 Documentation/config/lsrefs.txt diff --git a/Documentation/config.txt b/Documentation/config.txt index 6ba50b1104..d08e83a148 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -398,6 +398,8 @@ include::config/interactive.txt[] include::config/log.txt[] +include::config/lsrefs.txt[] + include::config/mailinfo.txt[] include::config/mailmap.txt[] diff --git a/Documentation/config/lsrefs.txt b/Documentation/config/lsrefs.txt new file mode 100644 index 0000000000..e003856c08 --- /dev/null +++ b/Documentation/config/lsrefs.txt @@ -0,0 +1,9 @@ +lsrefs.unborn:: + May be "advertise" (the default), "allow", or "ignore". If "advertise", + the server will respond to the client sending "unborn" (as described in + protocol-v2.txt) and will advertise support for this feature during the + protocol v2 capability advertisement. "allow" is the same as + "advertise" except that the server will not advertise support for this + feature; this is useful for load-balanced servers that cannot be + updated automatically (for example), since the administrator could + configure "allow", then after a delay, configure "advertise". diff --git a/Documentation/technical/protocol-v2.txt b/Documentation/technical/protocol-v2.txt index 85daeb5d9e..f772d90eaf 100644 --- a/Documentation/technical/protocol-v2.txt +++ b/Documentation/technical/protocol-v2.txt @@ -192,11 +192,20 @@ ls-refs takes in the following arguments: When specified, only references having a prefix matching one of the provided prefixes are displayed. +If the 'unborn' feature is advertised the following argument can be +included in the client's request. + + unborn + The server will send information about HEAD even if it is a symref + pointing to an unborn branch in the form "unborn HEAD + symref-target:". + The output of ls-refs is as follows: output = *ref flush-pkt - ref = PKT-LINE(obj-id SP refname *(SP ref-attribute) LF) + obj-id-or-unborn = (obj-id | "unborn") + ref = PKT-LINE(obj-id-or-unborn SP refname *(SP ref-attribute) LF) ref-attribute = (symref | peeled) symref = "symref-target:" symref-target peeled = "peeled:" obj-id diff --git a/ls-refs.c b/ls-refs.c index a1e0b473e4..e08fd43e7a 100644 --- a/ls-refs.c +++ b/ls-refs.c @@ -7,6 +7,39 @@ #include "pkt-line.h" #include "config.h" +static int config_read; +static int advertise_unborn; +static int allow_unborn; + +static void ensure_config_read(void) +{ + char *str = NULL; + + if (config_read) + return; + + if (repo_config_get_string(the_repository, "lsrefs.unborn", &str)) { + /* + * If there is no such config, advertise and allow it by + * default. + */ + advertise_unborn = 1; + allow_unborn = 1; + } else { + if (!strcmp(str, "advertise")) { + advertise_unborn = 1; + allow_unborn = 1; + } else if (!strcmp(str, "allow")) { + allow_unborn = 1; + } else if (!strcmp(str, "ignore")) { + /* do nothing */ + } else { + die(_("invalid value '%s' for lsrefs.unborn"), str); + } + } + config_read = 1; +} + /* * Check if one of the prefixes is a prefix of the ref. * If no prefixes were provided, all refs match. @@ -32,6 +65,7 @@ struct ls_refs_data { unsigned peel; unsigned symrefs; struct strvec prefixes; + unsigned unborn : 1; }; static int send_ref(const char *refname, const struct object_id *oid, @@ -47,7 +81,10 @@ static int send_ref(const char *refname, const struct object_id *oid, if (!ref_match(&data->prefixes, refname_nons)) return 0; - strbuf_addf(&refline, "%s %s", oid_to_hex(oid), refname_nons); + if (oid) + strbuf_addf(&refline, "%s %s", oid_to_hex(oid), refname_nons); + else + strbuf_addf(&refline, "unborn %s", refname_nons); if (data->symrefs && flag & REF_ISSYMREF) { struct object_id unused; const char *symref_target = resolve_ref_unsafe(refname, 0, @@ -61,7 +98,7 @@ static int send_ref(const char *refname, const struct object_id *oid, strip_namespace(symref_target)); } - if (data->peel) { + if (data->peel && oid) { struct object_id peeled; if (!peel_ref(refname, &peeled)) strbuf_addf(&refline, " peeled:%s", oid_to_hex(&peeled)); @@ -74,6 +111,23 @@ static int send_ref(const char *refname, const struct object_id *oid, return 0; } +static void send_possibly_unborn_head(struct ls_refs_data *data) +{ + struct strbuf namespaced = STRBUF_INIT; + struct object_id oid; + int flag; + int oid_is_null; + + strbuf_addf(&namespaced, "%sHEAD", get_git_namespace()); + if (!resolve_ref_unsafe(namespaced.buf, 0, &oid, &flag)) + return; /* bad ref */ + oid_is_null = is_null_oid(&oid); + if (!oid_is_null || + (data->unborn && data->symrefs && (flag & REF_ISSYMREF))) + send_ref(namespaced.buf, oid_is_null ? NULL : &oid, flag, data); + strbuf_release(&namespaced); +} + static int ls_refs_config(const char *var, const char *value, void *data) { /* @@ -91,6 +145,7 @@ int ls_refs(struct repository *r, struct strvec *keys, memset(&data, 0, sizeof(data)); + ensure_config_read(); git_config(ls_refs_config, NULL); while (packet_reader_read(request) == PACKET_READ_NORMAL) { @@ -103,14 +158,27 @@ int ls_refs(struct repository *r, struct strvec *keys, data.symrefs = 1; else if (skip_prefix(arg, "ref-prefix ", &out)) strvec_push(&data.prefixes, out); + else if (!strcmp("unborn", arg)) + data.unborn = allow_unborn; } if (request->status != PACKET_READ_FLUSH) die(_("expected flush after ls-refs arguments")); - head_ref_namespaced(send_ref, &data); + send_possibly_unborn_head(&data); for_each_namespaced_ref(send_ref, &data); packet_flush(1); strvec_clear(&data.prefixes); return 0; } + +int ls_refs_advertise(struct repository *r, struct strbuf *value) +{ + if (value) { + ensure_config_read(); + if (advertise_unborn) + strbuf_addstr(value, "unborn"); + } + + return 1; +} diff --git a/ls-refs.h b/ls-refs.h index 7b33a7c6b8..a99e4be0bd 100644 --- a/ls-refs.h +++ b/ls-refs.h @@ -6,5 +6,6 @@ struct strvec; struct packet_reader; int ls_refs(struct repository *r, struct strvec *keys, struct packet_reader *request); +int ls_refs_advertise(struct repository *r, struct strbuf *value); #endif /* LS_REFS_H */ diff --git a/serve.c b/serve.c index eec2fe6f29..ac20c72763 100644 --- a/serve.c +++ b/serve.c @@ -73,7 +73,7 @@ struct protocol_capability { static struct protocol_capability capabilities[] = { { "agent", agent_advertise, NULL }, - { "ls-refs", always_advertise, ls_refs }, + { "ls-refs", ls_refs_advertise, ls_refs }, { "fetch", upload_pack_advertise, upload_pack_v2 }, { "server-option", always_advertise, NULL }, { "object-format", object_format_advertise, NULL }, diff --git a/t/t5701-git-serve.sh b/t/t5701-git-serve.sh index a1f5fdc9fd..df29504161 100755 --- a/t/t5701-git-serve.sh +++ b/t/t5701-git-serve.sh @@ -12,7 +12,7 @@ test_expect_success 'test capability advertisement' ' cat >expect <<-EOF && version 2 agent=git/$(git version | cut -d" " -f3) - ls-refs + ls-refs=unborn fetch=shallow server-option object-format=$(test_oid algo) From patchwork Fri Feb 5 04:58:32 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Tan X-Patchwork-Id: 12069289 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.2 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DF59BC433E0 for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A370064F9C for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231207AbhBEE7j (ORCPT ); Thu, 4 Feb 2021 23:59:39 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43772 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231175AbhBEE7V (ORCPT ); Thu, 4 Feb 2021 23:59:21 -0500 Received: from mail-pj1-x1049.google.com (mail-pj1-x1049.google.com [IPv6:2607:f8b0:4864:20::1049]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9C706C06178B for ; Thu, 4 Feb 2021 20:58:41 -0800 (PST) Received: by mail-pj1-x1049.google.com with SMTP id x11so1982355pjn.2 for ; Thu, 04 Feb 2021 20:58:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=fpFYBWWcFL4809MKQJpr9Xe8M++GWLDFFj3NKw6THe0=; b=OOvifgAzeQhltcKqDEYEOWbypKG+sQdo8/75sAocarGgcYsNW9KM53rYJ6RME5aB9C qmUdIkV9BWvDLdxSPEWG7sumpXjDQWR275Vtzxu7ko8U9+pYcsToMwxxKy0q8LY4zaiI bu/CAdw4AAWoUpI2irwN+4NQ0Hwau2syfIuS6/uuHp/Y64CXO7SWGux3DYVHqKlt8RJ9 9zyURQSn9ZUYhOxjc5j4SSf6umbzQPVJxnjRwm4wzAvrNWoOuZNjjUJtqCumIS7Wx/pW TQ4X7fYm/jxNQUtId1EZiqHSmSsi3r0k51F0XXBE0c037FUzVapGKHwEy881xHXLZhZ4 whFQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=fpFYBWWcFL4809MKQJpr9Xe8M++GWLDFFj3NKw6THe0=; b=B2sRIJqQGvA/JZmpQysq2br82s+ZPWoPiXhlticXrKitwLCHb93tkmnwUTagEiXu78 2DIRSnUlAQ05mHzBzrud/4J8wNnOJRA117EZ+r3FnZKZrR9LwLqzmnOqfhXtg4CJI2mz kGbtMbEwnxpxbrWimz5l4VJTEi+NB2zIY0TM/sdX7YF0QwV/eI1zgYeIyi17hf46HAby AJ/kdeRwb/OaNIJ270V+WSiSYw1aW/XZX5DJUAfxjPwuH3fejyyJbz6RM1EGMZU/xd8v //LPzTWYXAQLJbDKawuP7DFXLHS6iJdOavVYFbicckwDo7tJtMdmtd1wPGDTUKBMaNL1 BJCw== X-Gm-Message-State: AOAM532DmfbMhJ2CMAo69PgWiYftl9tA+Kf3xfnydn771+M/vkmhezcW OeXH1zX9Bk7o2R1lxqDwwsy+YqtBiwh2byM9doXZZxVnzH6p/9V7U0CihuP0cTrKgx9TaOAsCft tbFQlAip+D/Qs6x3RpOfwR1GIdpuTAIze0RKsGwXy59Qro8bGmJM7FVk8RZK0vQpu/CLLuigloR xn X-Google-Smtp-Source: ABdhPJwFsxyYT+AjAvFDTnZJo1FDdJqzajJrjnHkwZlqaoy/E7hSCrmFPL3/P26kXqK1oeUYHA1VTYsLsWT2/kemdYpj Sender: "jonathantanmy via sendgmr" X-Received: from twelve4.c.googlers.com ([fda3:e722:ac3:10:24:72f4:c0a8:437a]) (user=jonathantanmy job=sendgmr) by 2002:aa7:9ad3:0:b029:1b7:8afc:d9bd with SMTP id x19-20020aa79ad30000b02901b78afcd9bdmr2735375pfp.45.1612501121034; Thu, 04 Feb 2021 20:58:41 -0800 (PST) Date: Thu, 4 Feb 2021 20:58:32 -0800 In-Reply-To: Message-Id: Mime-Version: 1.0 References: <20201208013121.677494-1-jonathantanmy@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH v7 2/3] connect, transport: encapsulate arg in struct From: Jonathan Tan To: git@vger.kernel.org Cc: Jonathan Tan , gitster@pobox.com Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org In a future patch we plan to return the name of an unborn current branch from deep in the callchain to a caller via a new pointer parameter that points at a variable in the caller when the caller calls get_remote_refs() and transport_get_remote_refs(). In preparation for that, encapsulate the existing ref_prefixes parameter into a struct. The aforementioned unborn current branch will go into this new struct in the future patch. Signed-off-by: Jonathan Tan Signed-off-by: Junio C Hamano --- builtin/clone.c | 18 +++++++++++------- builtin/fetch-pack.c | 3 ++- builtin/fetch.c | 18 +++++++++++------- builtin/ls-remote.c | 9 +++++---- connect.c | 4 +++- remote.h | 4 +++- transport-helper.c | 5 +++-- transport-internal.h | 10 ++-------- transport.c | 23 ++++++++++++----------- transport.h | 21 ++++++++++++++------- 10 files changed, 66 insertions(+), 49 deletions(-) diff --git a/builtin/clone.c b/builtin/clone.c index a5630337e4..211d4f54b0 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -979,7 +979,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix) int err = 0, complete_refs_before_fetch = 1; int submodule_progress; - struct strvec ref_prefixes = STRVEC_INIT; + struct transport_ls_refs_options transport_ls_refs_options = + TRANSPORT_LS_REFS_OPTIONS_INIT; packet_trace_identity("clone"); @@ -1257,14 +1258,17 @@ int cmd_clone(int argc, const char **argv, const char *prefix) transport->smart_options->check_self_contained_and_connected = 1; - strvec_push(&ref_prefixes, "HEAD"); - refspec_ref_prefixes(&remote->fetch, &ref_prefixes); + strvec_push(&transport_ls_refs_options.ref_prefixes, "HEAD"); + refspec_ref_prefixes(&remote->fetch, + &transport_ls_refs_options.ref_prefixes); if (option_branch) - expand_ref_prefix(&ref_prefixes, option_branch); + expand_ref_prefix(&transport_ls_refs_options.ref_prefixes, + option_branch); if (!option_no_tags) - strvec_push(&ref_prefixes, "refs/tags/"); + strvec_push(&transport_ls_refs_options.ref_prefixes, + "refs/tags/"); - refs = transport_get_remote_refs(transport, &ref_prefixes); + refs = transport_get_remote_refs(transport, &transport_ls_refs_options); if (refs) { int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport)); @@ -1380,6 +1384,6 @@ int cmd_clone(int argc, const char **argv, const char *prefix) strbuf_release(&key); junk_mode = JUNK_LEAVE_ALL; - strvec_clear(&ref_prefixes); + strvec_clear(&transport_ls_refs_options.ref_prefixes); return err; } diff --git a/builtin/fetch-pack.c b/builtin/fetch-pack.c index 58b7c1fbdc..c2d96f4c89 100644 --- a/builtin/fetch-pack.c +++ b/builtin/fetch-pack.c @@ -220,7 +220,8 @@ int cmd_fetch_pack(int argc, const char **argv, const char *prefix) version = discover_version(&reader); switch (version) { case protocol_v2: - get_remote_refs(fd[1], &reader, &ref, 0, NULL, NULL, args.stateless_rpc); + get_remote_refs(fd[1], &reader, &ref, 0, NULL, NULL, + args.stateless_rpc); break; case protocol_v1: case protocol_v0: diff --git a/builtin/fetch.c b/builtin/fetch.c index ecf8537605..837382ef4f 100644 --- a/builtin/fetch.c +++ b/builtin/fetch.c @@ -1349,7 +1349,8 @@ static int do_fetch(struct transport *transport, int autotags = (transport->remote->fetch_tags == 1); int retcode = 0; const struct ref *remote_refs; - struct strvec ref_prefixes = STRVEC_INIT; + struct transport_ls_refs_options transport_ls_refs_options = + TRANSPORT_LS_REFS_OPTIONS_INIT; int must_list_refs = 1; if (tags == TAGS_DEFAULT) { @@ -1369,7 +1370,7 @@ static int do_fetch(struct transport *transport, if (rs->nr) { int i; - refspec_ref_prefixes(rs, &ref_prefixes); + refspec_ref_prefixes(rs, &transport_ls_refs_options.ref_prefixes); /* * We can avoid listing refs if all of them are exact @@ -1383,22 +1384,25 @@ static int do_fetch(struct transport *transport, } } } else if (transport->remote && transport->remote->fetch.nr) - refspec_ref_prefixes(&transport->remote->fetch, &ref_prefixes); + refspec_ref_prefixes(&transport->remote->fetch, + &transport_ls_refs_options.ref_prefixes); if (tags == TAGS_SET || tags == TAGS_DEFAULT) { must_list_refs = 1; - if (ref_prefixes.nr) - strvec_push(&ref_prefixes, "refs/tags/"); + if (transport_ls_refs_options.ref_prefixes.nr) + strvec_push(&transport_ls_refs_options.ref_prefixes, + "refs/tags/"); } if (must_list_refs) { trace2_region_enter("fetch", "remote_refs", the_repository); - remote_refs = transport_get_remote_refs(transport, &ref_prefixes); + remote_refs = transport_get_remote_refs(transport, + &transport_ls_refs_options); trace2_region_leave("fetch", "remote_refs", the_repository); } else remote_refs = NULL; - strvec_clear(&ref_prefixes); + strvec_clear(&transport_ls_refs_options.ref_prefixes); ref_map = get_ref_map(transport->remote, remote_refs, rs, tags, &autotags); diff --git a/builtin/ls-remote.c b/builtin/ls-remote.c index 092917eca2..ef604752a0 100644 --- a/builtin/ls-remote.c +++ b/builtin/ls-remote.c @@ -45,7 +45,8 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix) int show_symref_target = 0; const char *uploadpack = NULL; const char **pattern = NULL; - struct strvec ref_prefixes = STRVEC_INIT; + struct transport_ls_refs_options transport_options = + TRANSPORT_LS_REFS_OPTIONS_INIT; int i; struct string_list server_options = STRING_LIST_INIT_DUP; @@ -94,9 +95,9 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix) } if (flags & REF_TAGS) - strvec_push(&ref_prefixes, "refs/tags/"); + strvec_push(&transport_options.ref_prefixes, "refs/tags/"); if (flags & REF_HEADS) - strvec_push(&ref_prefixes, "refs/heads/"); + strvec_push(&transport_options.ref_prefixes, "refs/heads/"); remote = remote_get(dest); if (!remote) { @@ -118,7 +119,7 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix) if (server_options.nr) transport->server_options = &server_options; - ref = transport_get_remote_refs(transport, &ref_prefixes); + ref = transport_get_remote_refs(transport, &transport_options); if (ref) { int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport)); repo_set_hash_algo(the_repository, hash_algo); diff --git a/connect.c b/connect.c index 8b8f56cf6d..328c279250 100644 --- a/connect.c +++ b/connect.c @@ -453,12 +453,14 @@ void check_stateless_delimiter(int stateless_rpc, struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, struct ref **list, int for_push, - const struct strvec *ref_prefixes, + struct transport_ls_refs_options *transport_options, const struct string_list *server_options, int stateless_rpc) { int i; const char *hash_name; + struct strvec *ref_prefixes = transport_options ? + &transport_options->ref_prefixes : NULL; *list = NULL; if (server_supports_v2("ls-refs", 1)) diff --git a/remote.h b/remote.h index 3211abdf05..4ae676a11b 100644 --- a/remote.h +++ b/remote.h @@ -6,6 +6,8 @@ #include "hashmap.h" #include "refspec.h" +struct transport_ls_refs_options; + /** * The API gives access to the configuration related to remotes. It handles * all three configuration mechanisms historically and currently used by Git, @@ -196,7 +198,7 @@ struct ref **get_remote_heads(struct packet_reader *reader, /* Used for protocol v2 in order to retrieve refs from a remote */ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, struct ref **list, int for_push, - const struct strvec *ref_prefixes, + struct transport_ls_refs_options *transport_options, const struct string_list *server_options, int stateless_rpc); diff --git a/transport-helper.c b/transport-helper.c index 5f6e0b3bd8..49b7fb4dcb 100644 --- a/transport-helper.c +++ b/transport-helper.c @@ -1162,13 +1162,14 @@ static int has_attribute(const char *attrs, const char *attr) } static struct ref *get_refs_list(struct transport *transport, int for_push, - const struct strvec *ref_prefixes) + struct transport_ls_refs_options *transport_options) { get_helper(transport); if (process_connect(transport, for_push)) { do_take_over(transport); - return transport->vtable->get_refs_list(transport, for_push, ref_prefixes); + return transport->vtable->get_refs_list(transport, for_push, + transport_options); } return get_refs_list_using_list(transport, for_push); diff --git a/transport-internal.h b/transport-internal.h index 27c9daffc4..b60f1ba907 100644 --- a/transport-internal.h +++ b/transport-internal.h @@ -4,6 +4,7 @@ struct ref; struct transport; struct strvec; +struct transport_ls_refs_options; struct transport_vtable { /** @@ -18,19 +19,12 @@ struct transport_vtable { * the transport to try to share connections, for_push is a * hint as to whether the ultimate operation is a push or a fetch. * - * If communicating using protocol v2 a list of prefixes can be - * provided to be sent to the server to enable it to limit the ref - * advertisement. Since ref filtering is done on the server's end, and - * only when using protocol v2, this list will be ignored when not - * using protocol v2 meaning this function can return refs which don't - * match the provided ref_prefixes. - * * If the transport is able to determine the remote hash for * the ref without a huge amount of effort, it should store it * in the ref's old_sha1 field; otherwise it should be all 0. **/ struct ref *(*get_refs_list)(struct transport *transport, int for_push, - const struct strvec *ref_prefixes); + struct transport_ls_refs_options *transport_options); /** * Fetch the objects for the given refs. Note that this gets diff --git a/transport.c b/transport.c index 679a35e7c1..b13fab5dc3 100644 --- a/transport.c +++ b/transport.c @@ -127,7 +127,7 @@ struct bundle_transport_data { static struct ref *get_refs_from_bundle(struct transport *transport, int for_push, - const struct strvec *ref_prefixes) + struct transport_ls_refs_options *transport_options) { struct bundle_transport_data *data = transport->data; struct ref *result = NULL; @@ -280,7 +280,7 @@ static void die_if_server_options(struct transport *transport) * remote refs. */ static struct ref *handshake(struct transport *transport, int for_push, - const struct strvec *ref_prefixes, + struct transport_ls_refs_options *options, int must_list_refs) { struct git_transport_data *data = transport->data; @@ -303,7 +303,7 @@ static struct ref *handshake(struct transport *transport, int for_push, trace2_data_string("transfer", NULL, "server-sid", server_sid); if (must_list_refs) get_remote_refs(data->fd[1], &reader, &refs, for_push, - ref_prefixes, + options, transport->server_options, transport->stateless_rpc); break; @@ -334,9 +334,9 @@ static struct ref *handshake(struct transport *transport, int for_push, } static struct ref *get_refs_via_connect(struct transport *transport, int for_push, - const struct strvec *ref_prefixes) + struct transport_ls_refs_options *options) { - return handshake(transport, for_push, ref_prefixes, 1); + return handshake(transport, for_push, options, 1); } static int fetch_refs_via_pack(struct transport *transport, @@ -1252,19 +1252,20 @@ int transport_push(struct repository *r, int porcelain = flags & TRANSPORT_PUSH_PORCELAIN; int pretend = flags & TRANSPORT_PUSH_DRY_RUN; int push_ret, ret, err; - struct strvec ref_prefixes = STRVEC_INIT; + struct transport_ls_refs_options transport_options = + TRANSPORT_LS_REFS_OPTIONS_INIT; if (check_push_refs(local_refs, rs) < 0) return -1; - refspec_ref_prefixes(rs, &ref_prefixes); + refspec_ref_prefixes(rs, &transport_options.ref_prefixes); trace2_region_enter("transport_push", "get_refs_list", r); remote_refs = transport->vtable->get_refs_list(transport, 1, - &ref_prefixes); + &transport_options); trace2_region_leave("transport_push", "get_refs_list", r); - strvec_clear(&ref_prefixes); + strvec_clear(&transport_options.ref_prefixes); if (flags & TRANSPORT_PUSH_ALL) match_flags |= MATCH_REFS_ALL; @@ -1380,12 +1381,12 @@ int transport_push(struct repository *r, } const struct ref *transport_get_remote_refs(struct transport *transport, - const struct strvec *ref_prefixes) + struct transport_ls_refs_options *transport_options) { if (!transport->got_remote_refs) { transport->remote_refs = transport->vtable->get_refs_list(transport, 0, - ref_prefixes); + transport_options); transport->got_remote_refs = 1; } diff --git a/transport.h b/transport.h index 24558c027d..1f5b60e4d3 100644 --- a/transport.h +++ b/transport.h @@ -233,17 +233,24 @@ int transport_push(struct repository *repo, struct refspec *rs, int flags, unsigned int * reject_reasons); +struct transport_ls_refs_options { + /* + * Optionally, a list of ref prefixes can be provided which can be sent + * to the server (when communicating using protocol v2) to enable it to + * limit the ref advertisement. Since ref filtering is done on the + * server's end (and only when using protocol v2), + * transport_get_remote_refs() could return refs which don't match the + * provided ref_prefixes. + */ + struct strvec ref_prefixes; +}; +#define TRANSPORT_LS_REFS_OPTIONS_INIT { STRVEC_INIT } + /* * Retrieve refs from a remote. - * - * Optionally a list of ref prefixes can be provided which can be sent to the - * server (when communicating using protocol v2) to enable it to limit the ref - * advertisement. Since ref filtering is done on the server's end (and only - * when using protocol v2), this can return refs which don't match the provided - * ref_prefixes. */ const struct ref *transport_get_remote_refs(struct transport *transport, - const struct strvec *ref_prefixes); + struct transport_ls_refs_options *transport_options); /* * Fetch the hash algorithm used by a remote. From patchwork Fri Feb 5 04:58:33 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Tan X-Patchwork-Id: 12069291 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.2 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EEA7DC433E6 for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C329E64F45 for ; Fri, 5 Feb 2021 04:59:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231214AbhBEE7m (ORCPT ); Thu, 4 Feb 2021 23:59:42 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43782 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231196AbhBEE7Y (ORCPT ); Thu, 4 Feb 2021 23:59:24 -0500 Received: from mail-pl1-x64a.google.com (mail-pl1-x64a.google.com [IPv6:2607:f8b0:4864:20::64a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EE996C06178C for ; Thu, 4 Feb 2021 20:58:43 -0800 (PST) Received: by mail-pl1-x64a.google.com with SMTP id w22so3653399pll.6 for ; Thu, 04 Feb 2021 20:58:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=3qA5U0eSO7FYCrtpzziYgWTqVrrAMC33eQ3CKXTU2eo=; b=oScovOswxEfrfM7EiLwYiK9RCLngLRTrAbymJpljTZ952toRLwbbMuI4BGMnNX9uXm A6/bBi8J7CQE5CM2Yx/sqGmsp28BUspwKgnKuXczVZujE1OLjpKwYH55Ax3oWvJP4rFX L1icTeWGgO0pgoL3YAfHknpCFRlCeNLWfO6VpmnCxjb6pSJJynNkpFwRHFku/5KMwX3F uu52N9TuTnqSqS8wszjeo4mYg48MlV5ifXio+E/Ef6yJWGoWg8crmX9nxkPdolvg5mwR 02ra7Qp5JxMhSdp8Z2BoDCtLqdZtjByuNfxORC509cTIobRNowaDjqXBOxLdEPb+yytk Czug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=3qA5U0eSO7FYCrtpzziYgWTqVrrAMC33eQ3CKXTU2eo=; b=FNtsepky/w1bXFlJyviddqbZuKjq4BxyIRkSlbPUQY++bgNWyurMYlAzgH0VM9UYCc gsBXsfmvlJnl3+unpuyCwOLVG0Qtu7snXHH6ftfWzzHlbYgW33K9TnxiEWBDfMznsR8q v+EzdGodBmOTlnK2r6Xqby3ubvXc+0XOfIg594fwCkIxe7J8GwUkDarlTv2v6cwMl9AM oMNfQiD8SE1cYEZLdzJ6KEzyIivI/4VK8tHQNpembdCyBmtsQlyC++UQ0QfZjA8Cl+M4 aVl5+64FBO5UOnwe/wZL3i6fdiYsb0naw64J/DR5E6L5JicUtj/HxdvlHPXYxxTdhY8r 40og== X-Gm-Message-State: AOAM532pjYT1Q29oxn2YI91Azruaf1KvfQGAUO60Jy0Ihru/Q9Mou5oe bASx2A1yNNDWz6Tz/Mjc2QlCuhTdtfk/WPYxgMgHRZV6u622F+y0rBD2JrxXlSaq8gQ4rpxVNBM NAiosPCL0RON2pyZktvw700gbvRrIIiW+vKHwv0Y7aFj63m7XUOryZT9SqMCbjsiHuWk3qsRF0c MH X-Google-Smtp-Source: ABdhPJxFYcjhigQUsIzGp1A8R4FmEMrPc32gKaj6yIqD3iWnSxaqiKsyvFq/xrRAmfA8/sUb4gBUO6Y+PG81ba+Brb3N Sender: "jonathantanmy via sendgmr" X-Received: from twelve4.c.googlers.com ([fda3:e722:ac3:10:24:72f4:c0a8:437a]) (user=jonathantanmy job=sendgmr) by 2002:aa7:94b5:0:b029:1d7:f868:e48d with SMTP id a21-20020aa794b50000b02901d7f868e48dmr766597pfl.9.1612501122791; Thu, 04 Feb 2021 20:58:42 -0800 (PST) Date: Thu, 4 Feb 2021 20:58:33 -0800 In-Reply-To: Message-Id: Mime-Version: 1.0 References: <20201208013121.677494-1-jonathantanmy@google.com> X-Mailer: git-send-email 2.30.0.365.g02bc693789-goog Subject: [PATCH v7 3/3] clone: respect remote unborn HEAD From: Jonathan Tan To: git@vger.kernel.org Cc: Jonathan Tan , gitster@pobox.com Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Teach Git to use the "unborn" feature introduced in a previous patch as follows: Git will always send the "unborn" argument if it is supported by the server. During "git clone", if cloning an empty repository, Git will use the new information to determine the local branch to create. In all other cases, Git will ignore it. Signed-off-by: Jonathan Tan Signed-off-by: Junio C Hamano --- Documentation/config/init.txt | 2 +- builtin/clone.c | 16 ++++++++++++++-- connect.c | 28 ++++++++++++++++++++++++++-- t/t5606-clone-options.sh | 8 +++++--- t/t5702-protocol-v2.sh | 25 +++++++++++++++++++++++++ transport.h | 8 ++++++++ 6 files changed, 79 insertions(+), 8 deletions(-) diff --git a/Documentation/config/init.txt b/Documentation/config/init.txt index dc77f8c844..79c79d6617 100644 --- a/Documentation/config/init.txt +++ b/Documentation/config/init.txt @@ -4,4 +4,4 @@ init.templateDir:: init.defaultBranch:: Allows overriding the default branch name e.g. when initializing - a new repository or when cloning an empty repository. + a new repository. diff --git a/builtin/clone.c b/builtin/clone.c index 211d4f54b0..09dcd97a2e 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -1330,8 +1330,19 @@ int cmd_clone(int argc, const char **argv, const char *prefix) remote_head = NULL; option_no_checkout = 1; if (!option_bare) { - const char *branch = git_default_branch_name(); - char *ref = xstrfmt("refs/heads/%s", branch); + const char *branch; + char *ref; + + if (transport_ls_refs_options.unborn_head_target && + skip_prefix(transport_ls_refs_options.unborn_head_target, + "refs/heads/", &branch)) { + ref = transport_ls_refs_options.unborn_head_target; + transport_ls_refs_options.unborn_head_target = NULL; + create_symref("HEAD", ref, reflog_msg.buf); + } else { + branch = git_default_branch_name(); + ref = xstrfmt("refs/heads/%s", branch); + } install_branch_config(0, branch, remote_name, ref); free(ref); @@ -1385,5 +1396,6 @@ int cmd_clone(int argc, const char **argv, const char *prefix) junk_mode = JUNK_LEAVE_ALL; strvec_clear(&transport_ls_refs_options.ref_prefixes); + free(transport_ls_refs_options.unborn_head_target); return err; } diff --git a/connect.c b/connect.c index 328c279250..879669df93 100644 --- a/connect.c +++ b/connect.c @@ -376,7 +376,8 @@ struct ref **get_remote_heads(struct packet_reader *reader, } /* Returns 1 when a valid ref has been added to `list`, 0 otherwise */ -static int process_ref_v2(struct packet_reader *reader, struct ref ***list) +static int process_ref_v2(struct packet_reader *reader, struct ref ***list, + char **unborn_head_target) { int ret = 1; int i = 0; @@ -397,6 +398,25 @@ static int process_ref_v2(struct packet_reader *reader, struct ref ***list) goto out; } + if (!strcmp("unborn", line_sections.items[i].string)) { + i++; + if (unborn_head_target && + !strcmp("HEAD", line_sections.items[i++].string)) { + /* + * Look for the symref target (if any). If found, + * return it to the caller. + */ + for (; i < line_sections.nr; i++) { + const char *arg = line_sections.items[i].string; + + if (skip_prefix(arg, "symref-target:", &arg)) { + *unborn_head_target = xstrdup(arg); + break; + } + } + } + goto out; + } if (parse_oid_hex_algop(line_sections.items[i++].string, &old_oid, &end, reader->hash_algo) || *end) { ret = 0; @@ -461,6 +481,8 @@ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, const char *hash_name; struct strvec *ref_prefixes = transport_options ? &transport_options->ref_prefixes : NULL; + char **unborn_head_target = transport_options ? + &transport_options->unborn_head_target : NULL; *list = NULL; if (server_supports_v2("ls-refs", 1)) @@ -490,6 +512,8 @@ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, if (!for_push) packet_write_fmt(fd_out, "peel\n"); packet_write_fmt(fd_out, "symrefs\n"); + if (server_supports_feature("ls-refs", "unborn", 0)) + packet_write_fmt(fd_out, "unborn\n"); for (i = 0; ref_prefixes && i < ref_prefixes->nr; i++) { packet_write_fmt(fd_out, "ref-prefix %s\n", ref_prefixes->v[i]); @@ -498,7 +522,7 @@ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, /* Process response from server */ while (packet_reader_read(reader) == PACKET_READ_NORMAL) { - if (!process_ref_v2(reader, &list)) + if (!process_ref_v2(reader, &list, unborn_head_target)) die(_("invalid ls-refs response: %s"), reader->line); } diff --git a/t/t5606-clone-options.sh b/t/t5606-clone-options.sh index 7f082fb23b..ca6339a5fb 100755 --- a/t/t5606-clone-options.sh +++ b/t/t5606-clone-options.sh @@ -102,11 +102,13 @@ test_expect_success 'redirected clone -v does show progress' ' ' test_expect_success 'chooses correct default initial branch name' ' - git init --bare empty && + GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ + git -c init.defaultBranch=foo init --bare empty && + test_config -C empty lsrefs.unborn advertise && GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ git -c init.defaultBranch=up clone empty whats-up && - test refs/heads/up = $(git -C whats-up symbolic-ref HEAD) && - test refs/heads/up = $(git -C whats-up config branch.up.merge) + test refs/heads/foo = $(git -C whats-up symbolic-ref HEAD) && + test refs/heads/foo = $(git -C whats-up config branch.foo.merge) ' test_expect_success 'guesses initial branch name correctly' ' diff --git a/t/t5702-protocol-v2.sh b/t/t5702-protocol-v2.sh index 7d5b17909b..b2ead93af9 100755 --- a/t/t5702-protocol-v2.sh +++ b/t/t5702-protocol-v2.sh @@ -209,6 +209,31 @@ test_expect_success 'clone with file:// using protocol v2' ' grep "ref-prefix refs/tags/" log ' +test_expect_success 'clone of empty repo propagates name of default branch' ' + test_when_finished "rm -rf file_empty_parent file_empty_child" && + + GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ + git -c init.defaultBranch=mydefaultbranch init file_empty_parent && + + GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ + git -c init.defaultBranch=main -c protocol.version=2 \ + clone "file://$(pwd)/file_empty_parent" file_empty_child && + grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD +' + +test_expect_success '...but not if explicitly forbidden by config' ' + test_when_finished "rm -rf file_empty_parent file_empty_child" && + + GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ + git -c init.defaultBranch=mydefaultbranch init file_empty_parent && + test_config -C file_empty_parent lsrefs.unborn ignore && + + GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \ + git -c init.defaultBranch=main -c protocol.version=2 \ + clone "file://$(pwd)/file_empty_parent" file_empty_child && + ! grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD +' + test_expect_success 'fetch with file:// using protocol v2' ' test_when_finished "rm -f log" && diff --git a/transport.h b/transport.h index 1f5b60e4d3..24e15799e7 100644 --- a/transport.h +++ b/transport.h @@ -243,6 +243,14 @@ struct transport_ls_refs_options { * provided ref_prefixes. */ struct strvec ref_prefixes; + + /* + * If unborn_head_target is not NULL, and the remote reports HEAD as + * pointing to an unborn branch, transport_get_remote_refs() stores the + * unborn branch in unborn_head_target. It should be freed by the + * caller. + */ + char *unborn_head_target; }; #define TRANSPORT_LS_REFS_OPTIONS_INIT { STRVEC_INIT }