implement and test formatters for %{Varnish:hitmiss} and %{Varnish:handling}

src/format.c

@@ -59,6 +59,13 @@ typedef struct compiled_fmt_t {
 /* XXX: When FMT_Init is implemented, malloc to config.max_reclen */
 static char scratch[DEFAULT_MAX_RECLEN];
 
+static char hit[] = "hit";
+static char miss[] = "miss";
+static char pass[] = "pass";
+static char pipe[] = "pipe";
+static char error[] = "error";
+static char dash[] = "-";
+
 #if 0
 
 static compiled_fmt_t cformat, bformat, zformat;
@@ -68,11 +75,6 @@ static char i_arg[BUFSIZ] = "";
 static int read_rx_hdr = 0, read_tx_hdr = 0, read_vcl_log = 0,
     read_vcl_call = 0, ntags = 0;
 
-static char hit[4];
-static char miss[5];
-static char pass[5];
-static char dash[2];
-
 #endif
 
 void
@@ -579,41 +581,50 @@ format_Xttfb_backend(tx_t *tx, char *name, enum VSL_tag_e tag,
     format_Xttfb(tx, "Beresp", s, len);
 }
 
-#if 0
-
-static void
-format_VCL_disp(logline_t *ll, char *name, enum VSL_tag_e tag,
-    char **s, size_t *len)
+void
+format_VCL_disp(tx_t *tx, char *name, enum VSL_tag_e tag,
+                char **s, size_t *len)
 {
-    hdr_t *vcl_call = ll->vcl_call;
-    (void) tag;
+    logline_t *rec;
 
+    (void) tag;
     *s = dash;
 
-    for (int i = 0; i < vcl_call->nrec; i++) {
-        record_t *rec = &vcl_call->record[i];
-        if (strncmp(rec->data, "hit", rec->len) == 0) {
-            *s = hit;
-            break;
-        }
-        else if (strncmp(rec->data, "miss", rec->len) == 0) {
-            *s = miss;
-            break;
+    VSTAILQ_FOREACH(rec, &tx->lines, linelist) {
+        CHECK_OBJ_NOTNULL(rec, LOGLINE_MAGIC);
+        if (rec->tag != SLT_VCL_call && rec->tag != SLT_VCL_return)
+            continue;
+        get_payload(rec);
+        char *data = VSB_data(payload);
+        if (rec->tag == SLT_VCL_call) {
+            if (strcasecmp(data, "hit") == 0)
+                *s = hit;
+            else if (strcasecmp(data, "miss") == 0)
+                *s = miss;
+            else if (strcasecmp(data, "pass") == 0) {
+                if (*name == 'm')
+                    *s = miss;
+                else
+                    *s = pass;
+            }
+            else if (strcasecmp(data, "error") == 0) {
+                if (*name == 'm')
+                    *s = miss;
+                else
+                    *s = error;
+            }
         }
-        else if (strncmp(rec->data, "pass", rec->len) == 0) {
+        else if (strcasecmp(data, "pipe") == 0) {
             if (*name == 'm')
                 *s = miss;
             else
-                *s = pass;
-            break;
+                *s = pipe;
         }
-        else if (strncmp(rec->data, "pipe", rec->len) == 0)
-            break;
     }
-
     *len = strlen(*s);
 }
 
+#if 0
 
 static void
 format_VCL_Log(logline_t *ll, char *name, enum VSL_tag_e tag,

src/format.h

@@ -94,3 +94,5 @@ formatter_f format_Xt;
 
 formatter_f format_Xttfb_client;
 formatter_f format_Xttfb_backend;
+
+formatter_f format_VCL_disp;

src/test/test_format.c

@@ -72,6 +72,14 @@ set_record_data(logline_t *rec, chunk_t *chunk, const char *data,
         rec->tag = tag;
 }
 
+static void
+add_record_data(tx_t *tx, logline_t *rec, chunk_t *chunk, const char *data,
+                enum VSL_tag_e tag)
+{
+    add_rec_chunk(tx, rec, chunk);
+    set_record_data(rec, chunk, data, tag);
+}
+
 /* N.B.: Always run the tests in this order */
 static const char
 *test_format_init(void)
@@ -1059,6 +1067,115 @@ static const char
     return NULL;
 }
 
+static const char
+*test_format_VCL_disp(void)
+{
+    tx_t tx;
+    logline_t *recs[NRECORDS];
+    chunk_t *c[NRECORDS];
+    char *str, hitmiss[] = "m", handling[] = "n";
+    size_t len;
+
+    printf("... testing format_VCL_disp_*()\n");
+
+    tx.magic = TX_MAGIC;
+    VSTAILQ_INIT(&tx.lines);
+    for (int i = 0; i < NRECORDS; i++) {
+        recs[i] = (logline_t *) calloc(1, sizeof(logline_t));
+        MAN(recs[i]);
+        c[i] = (chunk_t *) calloc(1, sizeof(chunk_t));
+        MAN(c[i]);
+    }
+
+    /* %{Varnish:hitmiss} for a hit */
+    add_record_data(&tx, recs[0], c[0], "RECV", SLT_VCL_call);
+    add_record_data(&tx, recs[1], c[1], "hash", SLT_VCL_return);
+    add_record_data(&tx, recs[2], c[2], "HASH", SLT_VCL_call);
+    add_record_data(&tx, recs[3], c[3], "lookup", SLT_VCL_return);
+    add_record_data(&tx, recs[4], c[4], "HIT", SLT_VCL_call);
+    add_record_data(&tx, recs[5], c[5], "deliver", SLT_VCL_return);
+    add_record_data(&tx, recs[6], c[6], "DELIVER", SLT_VCL_call);
+    add_record_data(&tx, recs[7], c[7], "deliver", SLT_VCL_return);
+    for (int i = 8; i < NRECORDS; i++)
+        add_record_data(&tx, recs[i], c[i], "", SLT__Bogus);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "hit") == 0);
+    MASSERT(len == 3);
+
+    /* %{Varnish:handling} for a hit */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "hit") == 0);
+    MASSERT(len == 3);
+
+    /* %{Varnish:hitmiss} for a miss */
+    add_record_data(&tx, recs[4], c[4], "MISS", SLT_VCL_call);
+    add_record_data(&tx, recs[5], c[5], "fetch", SLT_VCL_return);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "miss") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:handling} for a miss */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "miss") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:hitmiss} for a pass */
+    add_record_data(&tx, recs[4], c[4], "PASS", SLT_VCL_call);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "miss") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:handling} for a pass */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "pass") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:hitmiss} for an error */
+    add_record_data(&tx, recs[4], c[4], "ERROR", SLT_VCL_call);
+    add_record_data(&tx, recs[5], c[5], "synth", SLT_VCL_return);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "miss") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:handling} for an error */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "error") == 0);
+    MASSERT(len == 5);
+
+    /* %{Varnish:hitmiss} for noe of the above */
+    add_record_data(&tx, recs[0], c[0], "RECV", SLT_VCL_call);
+    add_record_data(&tx, recs[1], c[1], "synth", SLT_VCL_return);
+    add_record_data(&tx, recs[2], c[2], "HASH", SLT_VCL_call);
+    add_record_data(&tx, recs[3], c[3], "lookup", SLT_VCL_return);
+    add_record_data(&tx, recs[4], c[4], "SYNTH", SLT_VCL_call);
+    add_record_data(&tx, recs[5], c[5], "deliver", SLT_VCL_return);
+    for (int i = 6; i < NRECORDS; i++)
+        add_record_data(&tx, recs[i], c[i], "", SLT__Bogus);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "-") == 0);
+    MASSERT(len == 1);
+
+    /* %{Varnish:handling} for noe of the above */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "-") == 0);
+    MASSERT(len == 1);
+
+    /* %{Varnish:hitmiss} for a pipe */
+    add_record_data(&tx, recs[1], c[1], "pipe", SLT_VCL_return);
+    for (int i = 2; i < NRECORDS; i++)
+        add_record_data(&tx, recs[i], c[i], "", SLT__Bogus);
+    format_VCL_disp(&tx, hitmiss, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "miss") == 0);
+    MASSERT(len == 4);
+
+    /* %{Varnish:handling} for an pipe */
+    format_VCL_disp(&tx, handling, SLT__Bogus, &str, &len);
+    MASSERT(strcmp(str, "pipe") == 0);
+    MASSERT(len == 4);
+
+    return NULL;
+}
+
 static const char
 *all_tests(void)
 {
@@ -1087,6 +1204,7 @@ static const char
     mu_run_test(test_format_Xo);
     mu_run_test(test_format_Xt);
     mu_run_test(test_format_Xttfb);
+    mu_run_test(test_format_VCL_disp);
 
     return NULL;
 }