Add multi_ack_detailed capability to fetch-pack/upload-pack

When multi_ack_detailed is enabled the ACK continue messages returned
by the remote upload-pack are broken out to describe the different
states within the peer.  This permits the client to better understand
the server's in-memory state.

The fetch-pack/upload-pack protocol now looks like:

NAK
---------------------------------
Always sent in response to "done" if there was no common base
selected from the "have" lines (or no have lines were sent).

* no multi_ack or multi_ack_detailed:

Sent when the client has sent a pkt-line flush ("0000") and
the server has not yet found a common base object.

* either multi_ack or multi_ack_detailed:

Always sent in response to a pkt-line flush.

ACK %s
-----------------------------------
* no multi_ack or multi_ack_detailed:

Sent in response to "have" when the object exists on the remote
side and is therefore an object in common between the peers.
The argument is the SHA-1 of the common object.

* either multi_ack or multi_ack_detailed:

Sent in response to "done" if there are common objects.
The argument is the last SHA-1 determined to be common.

ACK %s continue
-----------------------------------
* multi_ack only:

Sent in response to "have".

The remote side wants the client to consider this object as
common, and immediately stop transmitting additional "have"
lines for objects that are reachable from it.  The reason
the client should stop is not given, but is one of the two
cases below available under multi_ack_detailed.

ACK %s common
-----------------------------------
* multi_ack_detailed only:

Sent in response to "have".  Both sides have this object.
Like with "ACK %s continue" above the client should stop
sending have lines reachable for objects from the argument.

ACK %s ready
-----------------------------------
* multi_ack_detailed only:

Sent in response to "have".

The client should stop transmitting objects which are reachable
from the argument, and send "done" soon to get the objects.

If the remote side has the specified object, it should
first send an "ACK %s common" message prior to sending
"ACK %s ready".

Clients may still submit additional "have" lines if there are
more side branches for the client to explore that might be added
to the common set and reduce the number of objects to transfer.

Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin-fetch-pack.c b/builtin-fetch-pack.c
index 7c09d466c85b645ef17b8456cd007011d50b3a5c..615f54974e0b19354d88a40ecba53f586944a96b 100644 (file)
--- a/builtin-fetch-pack.c
+++ b/builtin-fetch-pack.c
@@ -157,7 +157,15 @@ static const unsigned char *get_rev(void)
        return commit->object.sha1;
 }
 
        return commit->object.sha1;
 }
 

-static int get_ack(int fd, unsigned char *result_sha1)
+enum ack_type {
+       NAK = 0,
+       ACK,
+       ACK_continue,
+       ACK_common,
+       ACK_ready
+};
+
+static enum ack_type get_ack(int fd, unsigned char *result_sha1)

 {
        static char line[1000];
        int len = packet_read_line(fd, line, sizeof(line));
 {
        static char line[1000];
        int len = packet_read_line(fd, line, sizeof(line));


@@ -167,12 +175,16 @@ static int get_ack(int fd, unsigned char *result_sha1)
        if (line[len-1] == '\n')
                line[--len] = 0;
        if (!strcmp(line, "NAK"))
        if (line[len-1] == '\n')
                line[--len] = 0;
        if (!strcmp(line, "NAK"))

-               return 0;
+               return NAK;

        if (!prefixcmp(line, "ACK ")) {
                if (!get_sha1_hex(line+4, result_sha1)) {
                        if (strstr(line+45, "continue"))
        if (!prefixcmp(line, "ACK ")) {
                if (!get_sha1_hex(line+4, result_sha1)) {
                        if (strstr(line+45, "continue"))

-                               return 2;
-                       return 1;
+                               return ACK_continue;
+                       if (strstr(line+45, "common"))
+                               return ACK_common;
+                       if (strstr(line+45, "ready"))
+                               return ACK_ready;
+                       return ACK;

                }
        }
        die("git fetch_pack: expected ACK/NAK, got '%s'", line);
                }
        }
        die("git fetch_pack: expected ACK/NAK, got '%s'", line);


@@ -218,7 +230,8 @@ static int find_common(int fd[2], unsigned char *result_sha1,
                remote_hex = sha1_to_hex(remote);
                if (!fetching) {
                        struct strbuf c = STRBUF_INIT;
                remote_hex = sha1_to_hex(remote);
                if (!fetching) {
                        struct strbuf c = STRBUF_INIT;

-                       if (multi_ack)          strbuf_addstr(&c, " multi_ack");
+                       if (multi_ack == 2)     strbuf_addstr(&c, " multi_ack_detailed");
+                       if (multi_ack == 1)     strbuf_addstr(&c, " multi_ack");

                        if (use_sideband == 2)  strbuf_addstr(&c, " side-band-64k");
                        if (use_sideband == 1)  strbuf_addstr(&c, " side-band");
                        if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
                        if (use_sideband == 2)  strbuf_addstr(&c, " side-band-64k");
                        if (use_sideband == 1)  strbuf_addstr(&c, " side-band");
                        if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");


@@ -298,18 +311,23 @@ static int find_common(int fd[2], unsigned char *result_sha1,
                                if (args.verbose && ack)
                                        fprintf(stderr, "got ack %d %s\n", ack,
                                                        sha1_to_hex(result_sha1));
                                if (args.verbose && ack)
                                        fprintf(stderr, "got ack %d %s\n", ack,
                                                        sha1_to_hex(result_sha1));

-                               if (ack == 1) {
+                               switch (ack) {
+                               case ACK:

                                        flushes = 0;
                                        multi_ack = 0;
                                        retval = 0;
                                        goto done;
                                        flushes = 0;
                                        multi_ack = 0;
                                        retval = 0;
                                        goto done;

-                               } else if (ack == 2) {
+                               case ACK_common:
+                               case ACK_ready:
+                               case ACK_continue: {

                                        struct commit *commit =
                                                lookup_commit(result_sha1);
                                        mark_common(commit, 0, 1);
                                        retval = 0;
                                        in_vain = 0;
                                        got_continue = 1;
                                        struct commit *commit =
                                                lookup_commit(result_sha1);
                                        mark_common(commit, 0, 1);
                                        retval = 0;
                                        in_vain = 0;
                                        got_continue = 1;

+                                       break;
+                                       }

                                }
                        } while (ack);
                        flushes--;
                                }
                        } while (ack);
                        flushes--;


@@ -336,7 +354,7 @@ static int find_common(int fd[2], unsigned char *result_sha1,
                        if (args.verbose)
                                fprintf(stderr, "got ack (%d) %s\n", ack,
                                        sha1_to_hex(result_sha1));
                        if (args.verbose)
                                fprintf(stderr, "got ack (%d) %s\n", ack,
                                        sha1_to_hex(result_sha1));

-                       if (ack == 1)
+                       if (ack == ACK)

                                return 0;
                        multi_ack = 1;
                        continue;
                                return 0;
                        multi_ack = 1;
                        continue;


@@ -618,7 +636,12 @@ static struct ref *do_fetch_pack(int fd[2],
 
        if (is_repository_shallow() && !server_supports("shallow"))
                die("Server does not support shallow clients");
 
        if (is_repository_shallow() && !server_supports("shallow"))
                die("Server does not support shallow clients");

-       if (server_supports("multi_ack")) {
+       if (server_supports("multi_ack_detailed")) {
+               if (args.verbose)
+                       fprintf(stderr, "Server supports multi_ack_detailed\n");
+               multi_ack = 2;
+       }
+       else if (server_supports("multi_ack")) {

                if (args.verbose)
                        fprintf(stderr, "Server supports multi_ack\n");
                multi_ack = 1;
                if (args.verbose)
                        fprintf(stderr, "Server supports multi_ack\n");
                multi_ack = 1;

diff --git a/upload-pack.c b/upload-pack.c
index 38ddac2e8607f4cc6a801eeb49ba755dd89ee81c..f1dc3a351c522a91acb9663f832f2a18a9c20dc2 100644 (file)
--- a/upload-pack.c
+++ b/upload-pack.c
@@ -498,7 +498,7 @@ static int get_common_commits(void)
 {
        static char line[1000];
        unsigned char sha1[20];
 {
        static char line[1000];
        unsigned char sha1[20];

-       char hex[41], last_hex[41];
+       char last_hex[41];

 
        save_commit_buffer = 0;
 
 
        save_commit_buffer = 0;
 


@@ -515,19 +515,22 @@ static int get_common_commits(void)
                if (!prefixcmp(line, "have ")) {
                        switch (got_sha1(line+5, sha1)) {
                        case -1: /* they have what we do not */
                if (!prefixcmp(line, "have ")) {
                        switch (got_sha1(line+5, sha1)) {
                        case -1: /* they have what we do not */

-                               if (multi_ack && ok_to_give_up())
-                                       packet_write(1, "ACK %s continue\n",
-                                                    sha1_to_hex(sha1));
+                               if (multi_ack && ok_to_give_up()) {
+                                       const char *hex = sha1_to_hex(sha1);
+                                       if (multi_ack == 2)
+                                               packet_write(1, "ACK %s ready\n", hex);
+                                       else
+                                               packet_write(1, "ACK %s continue\n", hex);
+                               }

                                break;
                        default:
                                break;
                        default:

-                               memcpy(hex, sha1_to_hex(sha1), 41);
-                               if (multi_ack) {
-                                       const char *msg = "ACK %s continue\n";
-                                       packet_write(1, msg, hex);
-                                       memcpy(last_hex, hex, 41);
-                               }
+                               memcpy(last_hex, sha1_to_hex(sha1), 41);
+                               if (multi_ack == 2)
+                                       packet_write(1, "ACK %s common\n", last_hex);
+                               else if (multi_ack)
+                                       packet_write(1, "ACK %s continue\n", last_hex);

                                else if (have_obj.nr == 1)
                                else if (have_obj.nr == 1)

-                                       packet_write(1, "ACK %s\n", hex);
+                                       packet_write(1, "ACK %s\n", last_hex);

                                break;
                        }
                        continue;
                                break;
                        }
                        continue;


@@ -587,7 +590,9 @@ static void receive_needs(void)
                    get_sha1_hex(line+5, sha1_buf))
                        die("git upload-pack: protocol error, "
                            "expected to get sha, not '%s'", line);
                    get_sha1_hex(line+5, sha1_buf))
                        die("git upload-pack: protocol error, "
                            "expected to get sha, not '%s'", line);

-               if (strstr(line+45, "multi_ack"))
+               if (strstr(line+45, "multi_ack_detailed"))
+                       multi_ack = 2;
+               else if (strstr(line+45, "multi_ack"))

                        multi_ack = 1;
                if (strstr(line+45, "thin-pack"))
                        use_thin_pack = 1;
                        multi_ack = 1;
                if (strstr(line+45, "thin-pack"))
                        use_thin_pack = 1;


@@ -681,7 +686,7 @@ static int send_ref(const char *refname, const unsigned char *sha1, int flag, vo
 {
        static const char *capabilities = "multi_ack thin-pack side-band"
                " side-band-64k ofs-delta shallow no-progress"
 {
        static const char *capabilities = "multi_ack thin-pack side-band"
                " side-band-64k ofs-delta shallow no-progress"

-               " include-tag";
+               " include-tag multi_ack_detailed";

        struct object *o = parse_object(sha1);
 
        if (!o)
        struct object *o = parse_object(sha1);
 
        if (!o)