Merge branch 'jk/pkt-log-pack'

Enhance packet tracing machinery to allow capturing an incoming
pack data to a file for debugging.

* jk/pkt-log-pack:
pkt-line: support tracing verbatim pack contents
pkt-line: tighten sideband PACK check when tracing
pkt-line: simplify starts_with checks in packet tracing

diff --git a/Documentation/git.txt b/Documentation/git.txt
index f4cb5cb200cf69461d5af39d4c29b51138e4d3ec..f87d3325f8b7bc02c7bfa74b6d242bd3d72af240 100644 (file)
--- a/Documentation/git.txt
+++ b/Documentation/git.txt
@@ -1009,9 +1009,20 @@ Unsetting the variable, or setting it to empty, "0" or
        Enables trace messages for all packets coming in or out of a
        given program. This can help with debugging object negotiation
        or other protocol issues. Tracing is turned off at a packet
-       starting with "PACK".
+       starting with "PACK" (but see 'GIT_TRACE_PACKFILE' below).
        See 'GIT_TRACE' for available trace output options.
 
+'GIT_TRACE_PACKFILE'::
+       Enables tracing of packfiles sent or received by a
+       given program. Unlike other trace output, this trace is
+       verbatim: no headers, and no quoting of binary data. You almost
+       certainly want to direct into a file (e.g.,
+       `GIT_TRACE_PACKFILE=/tmp/my.pack`) rather than displaying it on
+       the terminal or mixing it with other trace output.
++
+Note that this is currently only implemented for the client side
+of clones and fetches.
+
 'GIT_TRACE_PERFORMANCE'::
        Enables performance related trace messages, e.g. total execution
        time of each Git command.

diff --git a/pkt-line.c b/pkt-line.c
index 187a2293e7d9a36ba294fe775efcf2b87f4e9233..08a1427c0d4f6743182b235ec9d9c710c3c99b5b 100644 (file)
--- a/pkt-line.c
+++ b/pkt-line.c
@@ -4,16 +4,51 @@
 char packet_buffer[LARGE_PACKET_MAX];
 static const char *packet_trace_prefix = "git";
 static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET);
+static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE);
 
 void packet_trace_identity(const char *prog)
 {
        packet_trace_prefix = xstrdup(prog);
 }
 
+static int packet_trace_pack(const char *buf, unsigned int len, int sideband)
+{
+       if (!sideband) {
+               trace_verbatim(&trace_pack, buf, len);
+               return 1;
+       } else if (len && *buf == '\1') {
+               trace_verbatim(&trace_pack, buf + 1, len - 1);
+               return 1;
+       } else {
+               /* it's another non-pack sideband */
+               return 0;
+       }
+}
+
 static void packet_trace(const char *buf, unsigned int len, int write)
 {
        int i;
        struct strbuf out;
+       static int in_pack, sideband;
+
+       if (!trace_want(&trace_packet) && !trace_want(&trace_pack))
+               return;
+
+       if (in_pack) {
+               if (packet_trace_pack(buf, len, sideband))
+                       return;
+       } else if (starts_with(buf, "PACK") || starts_with(buf, "\1PACK")) {
+               in_pack = 1;
+               sideband = *buf == '\1';
+               packet_trace_pack(buf, len, sideband);
+
+               /*
+                * Make a note in the human-readable trace that the pack data
+                * started.
+                */
+               buf = "PACK ...";
+               len = strlen(buf);
+       }
 
        if (!trace_want(&trace_packet))
                return;
@@ -24,22 +59,15 @@ static void packet_trace(const char *buf, unsigned int len, int write)
        strbuf_addf(&out, "packet: %12s%c ",
                    packet_trace_prefix, write ? '>' : '<');
 
-       if ((len >= 4 && starts_with(buf, "PACK")) ||
-           (len >= 5 && starts_with(buf+1, "PACK"))) {
-               strbuf_addstr(&out, "PACK ...");
-               trace_disable(&trace_packet);
-       }
-       else {
-               /* XXX we should really handle printable utf8 */
-               for (i = 0; i < len; i++) {
-                       /* suppress newlines */
-                       if (buf[i] == '\n')
-                               continue;
-                       if (buf[i] >= 0x20 && buf[i] <= 0x7e)
-                               strbuf_addch(&out, buf[i]);
-                       else
-                               strbuf_addf(&out, "\\%o", buf[i]);
-               }
+       /* XXX we should really handle printable utf8 */
+       for (i = 0; i < len; i++) {
+               /* suppress newlines */
+               if (buf[i] == '\n')
+                       continue;
+               if (buf[i] >= 0x20 && buf[i] <= 0x7e)
+                       strbuf_addch(&out, buf[i]);
+               else
+                       strbuf_addf(&out, "\\%o", buf[i]);
        }
 
        strbuf_addch(&out, '\n');

diff --git a/t/t5601-clone.sh b/t/t5601-clone.sh
index bfdaf75966f7b8bb057e4db0b8791306f6e6a44f..9b34f3c615df5080085b5f8cf956d2bac099d9d4 100755 (executable)
--- a/t/t5601-clone.sh
+++ b/t/t5601-clone.sh
@@ -496,4 +496,11 @@ test_expect_success 'shallow clone locally' '
        ( cd ddsstt && git fsck )
 '
 
+test_expect_success 'GIT_TRACE_PACKFILE produces a usable pack' '
+       rm -rf dst.git &&
+       GIT_TRACE_PACKFILE=$PWD/tmp.pack git clone --no-local --bare src dst.git &&
+       git init --bare replay.git &&
+       git -C replay.git index-pack -v --stdin <tmp.pack
+'
+
 test_done

diff --git a/trace.c b/trace.c
index 3c3bd8fc98742075d6adc673ed2abc4f7e715b62..7393926ebcd95404fe16cdd84e40fd4f1bb02f40 100644 (file)
--- a/trace.c
+++ b/trace.c
@@ -120,6 +120,13 @@ static int prepare_trace_line(const char *file, int line,
        return 1;
 }
 
+void trace_verbatim(struct trace_key *key, const void *buf, unsigned len)
+{
+       if (!trace_want(key))
+               return;
+       write_or_whine_pipe(get_trace_fd(key), buf, len, err_msg);
+}
+
 static void print_trace_line(struct trace_key *key, struct strbuf *buf)
 {
        strbuf_complete_line(buf);

diff --git a/trace.h b/trace.h
index ae6a3329470cae428bb0864e51b14ea42078b182..179b249c597125ac8ad3ed2d0c0e6b00a94773eb 100644 (file)
--- a/trace.h
+++ b/trace.h
@@ -18,6 +18,7 @@ extern int trace_want(struct trace_key *key);
 extern void trace_disable(struct trace_key *key);
 extern uint64_t getnanotime(void);
 extern void trace_command_performance(const char **argv);
+extern void trace_verbatim(struct trace_key *key, const void *buf, unsigned len);
 
 #ifndef HAVE_VARIADIC_MACROS