fetch-pack: put shallow info in output parameter

Expand the transport fetch method signature, by adding an output
parameter, to allow transports to return information about the refs they
have fetched.  Then communicate shallow status information through this
mechanism instead of by modifying the input list of refs.

This does require clients to sometimes generate the ref map twice: once
from the list of refs provided by the remote (as is currently done) and
potentially once from the new list of refs that the fetch mechanism
provides.

Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/clone.c b/builtin/clone.c
index 99e73dae8595d37f704d0fe7f7fd84a190edfcf6..8f86d99c51f099805c752ba460cf99e6a77891b0 100644 (file)
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -1155,7 +1155,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
                        }
 
                if (!is_local && !complete_refs_before_fetch)
                        }
 
                if (!is_local && !complete_refs_before_fetch)

-                       transport_fetch_refs(transport, mapped_refs);
+                       transport_fetch_refs(transport, mapped_refs, NULL);

 
                remote_head = find_ref_by_name(refs, "HEAD");
                remote_head_points_at =
 
                remote_head = find_ref_by_name(refs, "HEAD");
                remote_head_points_at =


@@ -1197,7 +1197,7 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
        if (is_local)
                clone_local(path, git_dir);
        else if (refs && complete_refs_before_fetch)
        if (is_local)
                clone_local(path, git_dir);
        else if (refs && complete_refs_before_fetch)

-               transport_fetch_refs(transport, mapped_refs);
+               transport_fetch_refs(transport, mapped_refs, NULL);

 
        update_remote_refs(refs, mapped_refs, remote_head_points_at,
                           branch_top.buf, reflog_msg.buf, transport,
 
        update_remote_refs(refs, mapped_refs, remote_head_points_at,
                           branch_top.buf, reflog_msg.buf, transport,

diff --git a/builtin/fetch.c b/builtin/fetch.c
index bda00e82628b94eedc2a32c91ab49686c3a21879..0347cf01678ce42357829c0914ba3714f57540a2 100644 (file)
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -946,11 +946,13 @@ static int quickfetch(struct ref *ref_map)
        return check_connected(iterate_ref_map, &rm, &opt);
 }
 
        return check_connected(iterate_ref_map, &rm, &opt);
 }
 

-static int fetch_refs(struct transport *transport, struct ref *ref_map)
+static int fetch_refs(struct transport *transport, struct ref *ref_map,
+                     struct ref **updated_remote_refs)

 {
        int ret = quickfetch(ref_map);
        if (ret)
 {
        int ret = quickfetch(ref_map);
        if (ret)

-               ret = transport_fetch_refs(transport, ref_map);
+               ret = transport_fetch_refs(transport, ref_map,
+                                          updated_remote_refs);

        if (!ret)
                /*
                 * Keep the new pack's ".keep" file around to allow the caller
        if (!ret)
                /*
                 * Keep the new pack's ".keep" file around to allow the caller


@@ -1112,7 +1114,7 @@ static void backfill_tags(struct transport *transport, struct ref *ref_map)
        transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, NULL);
        transport_set_option(transport, TRANS_OPT_DEPTH, "0");
        transport_set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, NULL);
        transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, NULL);
        transport_set_option(transport, TRANS_OPT_DEPTH, "0");
        transport_set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, NULL);

-       if (!fetch_refs(transport, ref_map))
+       if (!fetch_refs(transport, ref_map, NULL))

                consume_refs(transport, ref_map);
 
        if (gsecondary) {
                consume_refs(transport, ref_map);
 
        if (gsecondary) {


@@ -1128,6 +1130,7 @@ static int do_fetch(struct transport *transport,
        int autotags = (transport->remote->fetch_tags == 1);
        int retcode = 0;
        const struct ref *remote_refs;
        int autotags = (transport->remote->fetch_tags == 1);
        int retcode = 0;
        const struct ref *remote_refs;

+       struct ref *updated_remote_refs = NULL;

        struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
 
        if (tags == TAGS_DEFAULT) {
        struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
 
        if (tags == TAGS_DEFAULT) {


@@ -1178,7 +1181,24 @@ static int do_fetch(struct transport *transport,
                                   transport->url);
                }
        }
                                   transport->url);
                }
        }

-       if (fetch_refs(transport, ref_map) || consume_refs(transport, ref_map)) {
+
+       if (fetch_refs(transport, ref_map, &updated_remote_refs)) {
+               free_refs(ref_map);
+               retcode = 1;
+               goto cleanup;
+       }
+       if (updated_remote_refs) {
+               /*
+                * Regenerate ref_map using the updated remote refs.  This is
+                * to account for additional information which may be provided
+                * by the transport (e.g. shallow info).
+                */
+               free_refs(ref_map);
+               ref_map = get_ref_map(transport->remote, updated_remote_refs, rs,
+                                     tags, &autotags);
+               free_refs(updated_remote_refs);
+       }
+       if (consume_refs(transport, ref_map)) {

                free_refs(ref_map);
                retcode = 1;
                goto cleanup;
                free_refs(ref_map);
                retcode = 1;
                goto cleanup;

diff --git a/fetch-object.c b/fetch-object.c
index 853624f811c59c17af88814ebeecf4154095a19c..48fe63dd6cf935d02724a0d862f43c070083bbf2 100644 (file)
--- a/fetch-object.c
+++ b/fetch-object.c
@@ -19,7 +19,7 @@ static void fetch_refs(const char *remote_name, struct ref *ref)
 
        transport_set_option(transport, TRANS_OPT_FROM_PROMISOR, "1");
        transport_set_option(transport, TRANS_OPT_NO_DEPENDENTS, "1");
 
        transport_set_option(transport, TRANS_OPT_FROM_PROMISOR, "1");
        transport_set_option(transport, TRANS_OPT_NO_DEPENDENTS, "1");

-       transport_fetch_refs(transport, ref);
+       transport_fetch_refs(transport, ref, NULL);

        fetch_if_missing = original_fetch_if_missing;
 }
 
        fetch_if_missing = original_fetch_if_missing;
 }
 

diff --git a/fetch-pack.c b/fetch-pack.c
index a320ce9872b5e752aeb592a16cc9108ae87e9d71..73890b8943595b2fe31a5b56cd390539ed26c23e 100644 (file)
--- a/fetch-pack.c
+++ b/fetch-pack.c
@@ -1470,12 +1470,13 @@ static int remove_duplicates_in_refs(struct ref **ref, int nr)
 }
 
 static void update_shallow(struct fetch_pack_args *args,
 }
 
 static void update_shallow(struct fetch_pack_args *args,

-                          struct ref **sought, int nr_sought,
+                          struct ref *refs,

                           struct shallow_info *si)
 {
        struct oid_array ref = OID_ARRAY_INIT;
        int *status;
        int i;
                           struct shallow_info *si)
 {
        struct oid_array ref = OID_ARRAY_INIT;
        int *status;
        int i;

+       struct ref *r;

 
        if (args->deepen && alternate_shallow_file) {
                if (*alternate_shallow_file == '\0') { /* --unshallow */
 
        if (args->deepen && alternate_shallow_file) {
                if (*alternate_shallow_file == '\0') { /* --unshallow */


@@ -1517,8 +1518,8 @@ static void update_shallow(struct fetch_pack_args *args,
        remove_nonexistent_theirs_shallow(si);
        if (!si->nr_ours && !si->nr_theirs)
                return;
        remove_nonexistent_theirs_shallow(si);
        if (!si->nr_ours && !si->nr_theirs)
                return;

-       for (i = 0; i < nr_sought; i++)
-               oid_array_append(&ref, &sought[i]->old_oid);
+       for (r = refs; r; r = r->next)
+               oid_array_append(&ref, &r->old_oid);

        si->ref = &ref;
 
        if (args->update_shallow) {
        si->ref = &ref;
 
        if (args->update_shallow) {


@@ -1552,12 +1553,12 @@ static void update_shallow(struct fetch_pack_args *args,
         * remote is also shallow, check what ref is safe to update
         * without updating .git/shallow
         */
         * remote is also shallow, check what ref is safe to update
         * without updating .git/shallow
         */

-       status = xcalloc(nr_sought, sizeof(*status));
+       status = xcalloc(ref.nr, sizeof(*status));

        assign_shallow_commits_to_refs(si, NULL, status);
        if (si->nr_ours || si->nr_theirs) {
        assign_shallow_commits_to_refs(si, NULL, status);
        if (si->nr_ours || si->nr_theirs) {

-               for (i = 0; i < nr_sought; i++)
+               for (r = refs, i = 0; r; r = r->next, i++)

                        if (status[i])
                        if (status[i])

-                               sought[i]->status = REF_STATUS_REJECT_SHALLOW;
+                               r->status = REF_STATUS_REJECT_SHALLOW;

        }
        free(status);
        oid_array_clear(&ref);
        }
        free(status);
        oid_array_clear(&ref);


@@ -1591,7 +1592,7 @@ struct ref *fetch_pack(struct fetch_pack_args *args,
                ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
                                        &si, pack_lockfile);
        reprepare_packed_git(the_repository);
                ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
                                        &si, pack_lockfile);
        reprepare_packed_git(the_repository);

-       update_shallow(args, sought, nr_sought, &si);
+       update_shallow(args, ref_cpy, &si);

        clear_shallow_info(&si);
        return ref_cpy;
 }
        clear_shallow_info(&si);
        return ref_cpy;
 }

diff --git a/transport-helper.c b/transport-helper.c
index 1f8ff7e9424e5d780578a6ab00623f814d8f836a..8b5abca29f9492c03c234170ae1c66ba9f0970bb 100644 (file)
--- a/transport-helper.c
+++ b/transport-helper.c
@@ -651,14 +651,16 @@ static int connect_helper(struct transport *transport, const char *name,
 }
 
 static int fetch(struct transport *transport,
 }
 
 static int fetch(struct transport *transport,

-                int nr_heads, struct ref **to_fetch)
+                int nr_heads, struct ref **to_fetch,
+                struct ref **fetched_refs)

 {
        struct helper_data *data = transport->data;
        int i, count;
 
        if (process_connect(transport, 0)) {
                do_take_over(transport);
 {
        struct helper_data *data = transport->data;
        int i, count;
 
        if (process_connect(transport, 0)) {
                do_take_over(transport);

-               return transport->vtable->fetch(transport, nr_heads, to_fetch);
+               return transport->vtable->fetch(transport, nr_heads, to_fetch,
+                                               fetched_refs);

        }
 
        count = 0;
        }
 
        count = 0;

diff --git a/transport-internal.h b/transport-internal.h
index 1cde6258a73bcf8582b0746d1c44a23b30115dc9..eeb6c340e51eab341b7f089bf2b425697759f3cd 100644 (file)
--- a/transport-internal.h
+++ b/transport-internal.h
@@ -36,11 +36,18 @@ struct transport_vtable {
         * Fetch the objects for the given refs. Note that this gets
         * an array, and should ignore the list structure.
         *
         * Fetch the objects for the given refs. Note that this gets
         * an array, and should ignore the list structure.
         *

+        * The transport *may* provide, in fetched_refs, the list of refs that
+        * it fetched.  If the transport knows anything about the fetched refs
+        * that the caller does not know (for example, shallow status), it
+        * should provide that list of refs and include that information in the
+        * list.
+        *

         * If the transport did not get hashes for refs in
         * get_refs_list(), it should set the old_sha1 fields in the
         * provided refs now.
         **/
         * If the transport did not get hashes for refs in
         * get_refs_list(), it should set the old_sha1 fields in the
         * provided refs now.
         **/

-       int (*fetch)(struct transport *transport, int refs_nr, struct ref **refs);
+       int (*fetch)(struct transport *transport, int refs_nr, struct ref **refs,
+                    struct ref **fetched_refs);

 
        /**
         * Push the objects and refs. Send the necessary objects, and
 
        /**
         * Push the objects and refs. Send the necessary objects, and

diff --git a/transport.c b/transport.c
index a32da30dee6f4e38433b68d7c9f7e9404aa58858..39d8c2fa552d69f2759475062e38a0132894bdcf 100644 (file)
--- a/transport.c
+++ b/transport.c
@@ -151,7 +151,8 @@ static struct ref *get_refs_from_bundle(struct transport *transport,
 }
 
 static int fetch_refs_from_bundle(struct transport *transport,
 }
 
 static int fetch_refs_from_bundle(struct transport *transport,

-                              int nr_heads, struct ref **to_fetch)
+                              int nr_heads, struct ref **to_fetch,
+                              struct ref **fetched_refs)

 {
        struct bundle_transport_data *data = transport->data;
        return unbundle(&data->header, data->fd,
 {
        struct bundle_transport_data *data = transport->data;
        return unbundle(&data->header, data->fd,


@@ -287,7 +288,8 @@ static struct ref *get_refs_via_connect(struct transport *transport, int for_pus
 }
 
 static int fetch_refs_via_pack(struct transport *transport,
 }
 
 static int fetch_refs_via_pack(struct transport *transport,

-                              int nr_heads, struct ref **to_fetch)
+                              int nr_heads, struct ref **to_fetch,
+                              struct ref **fetched_refs)

 {
        int ret = 0;
        struct git_transport_data *data = transport->data;
 {
        int ret = 0;
        struct git_transport_data *data = transport->data;


@@ -354,8 +356,12 @@ static int fetch_refs_via_pack(struct transport *transport,
        if (report_unmatched_refs(to_fetch, nr_heads))
                ret = -1;
 
        if (report_unmatched_refs(to_fetch, nr_heads))
                ret = -1;
 

+       if (fetched_refs)
+               *fetched_refs = refs;
+       else
+               free_refs(refs);
+

        free_refs(refs_tmp);
        free_refs(refs_tmp);

-       free_refs(refs);

        free(dest);
        return ret;
 }
        free(dest);
        return ret;
 }


@@ -1215,19 +1221,31 @@ const struct ref *transport_get_remote_refs(struct transport *transport,
        return transport->remote_refs;
 }
 
        return transport->remote_refs;
 }
 

-int transport_fetch_refs(struct transport *transport, struct ref *refs)
+int transport_fetch_refs(struct transport *transport, struct ref *refs,
+                        struct ref **fetched_refs)

 {
        int rc;
        int nr_heads = 0, nr_alloc = 0, nr_refs = 0;
        struct ref **heads = NULL;
 {
        int rc;
        int nr_heads = 0, nr_alloc = 0, nr_refs = 0;
        struct ref **heads = NULL;

+       struct ref *nop_head = NULL, **nop_tail = &nop_head;

        struct ref *rm;
 
        for (rm = refs; rm; rm = rm->next) {
                nr_refs++;
                if (rm->peer_ref &&
                    !is_null_oid(&rm->old_oid) &&
        struct ref *rm;
 
        for (rm = refs; rm; rm = rm->next) {
                nr_refs++;
                if (rm->peer_ref &&
                    !is_null_oid(&rm->old_oid) &&

-                   !oidcmp(&rm->peer_ref->old_oid, &rm->old_oid))
+                   !oidcmp(&rm->peer_ref->old_oid, &rm->old_oid)) {
+                       /*
+                        * These need to be reported as fetched, but we don't
+                        * actually need to fetch them.
+                        */
+                       if (fetched_refs) {
+                               struct ref *nop_ref = copy_ref(rm);
+                               *nop_tail = nop_ref;
+                               nop_tail = &nop_ref->next;
+                       }

                        continue;
                        continue;

+               }

                ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
                heads[nr_heads++] = rm;
        }
                ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
                heads[nr_heads++] = rm;
        }


@@ -1245,7 +1263,11 @@ int transport_fetch_refs(struct transport *transport, struct ref *refs)
                        heads[nr_heads++] = rm;
        }
 
                        heads[nr_heads++] = rm;
        }
 

-       rc = transport->vtable->fetch(transport, nr_heads, heads);
+       rc = transport->vtable->fetch(transport, nr_heads, heads, fetched_refs);
+       if (fetched_refs && nop_head) {
+               *nop_tail = *fetched_refs;
+               *fetched_refs = nop_head;
+       }

 
        free(heads);
        return rc;
 
        free(heads);
        return rc;

diff --git a/transport.h b/transport.h
index 7792b08582c132e18b495a21b700d9113727c7eb..3dff767a87e3df879458546ca2436a9d71ca440a 100644 (file)
--- a/transport.h
+++ b/transport.h
@@ -218,7 +218,8 @@ int transport_push(struct transport *connection,
 const struct ref *transport_get_remote_refs(struct transport *transport,
                                            const struct argv_array *ref_prefixes);
 
 const struct ref *transport_get_remote_refs(struct transport *transport,
                                            const struct argv_array *ref_prefixes);
 

-int transport_fetch_refs(struct transport *transport, struct ref *refs);
+int transport_fetch_refs(struct transport *transport, struct ref *refs,
+                        struct ref **fetched_refs);

 void transport_unlock_pack(struct transport *transport);
 int transport_disconnect(struct transport *transport);
 char *transport_anonymize_url(const char *url);
 void transport_unlock_pack(struct transport *transport);
 int transport_disconnect(struct transport *transport);
 char *transport_anonymize_url(const char *url);