Emit valid YAML for cachemgr:server_list

src/CachePeer.cc

@@ -8,6 +8,8 @@
 
 #include "squid.h"
 #include "acl/Gadgets.h"
+#include "base/EnumIterator.h"
+#include "base/IoManip.h"
 #include "CachePeer.h"
 #include "defines.h"
 #include "neighbors.h"
@@ -16,6 +18,7 @@
 #include "PeerDigest.h"
 #include "PeerPoolMgr.h"
 #include "SquidConfig.h"
+#include "SquidMath.h"
 #include "util.h"
 
 CBDATA_CLASS_INIT(CachePeer);
@@ -85,7 +88,7 @@ CachePeer::noteFailure()
 
     if (consideredAliveByAdmin) {
         if (!tcp_up) {
-            debugs(15, DBG_IMPORTANT, "Detected DEAD " << neighborTypeStr(this) << ": " << name);
+            debugs(15, DBG_IMPORTANT, "Detected DEAD " << typeString() << ": " << name);
             stats.logged_state = PEER_DEAD;
         } else {
             debugs(15, 2, "additional failures needed to mark this cache_peer DEAD: " << tcp_up);
@@ -114,6 +117,206 @@ CachePeer::connectTimeout() const
     return Config.Timeout.peer_connect;
 }
 
+void
+CachePeer::dumpOptions(std::ostream &yaml) const
+{
+    if (options.proxy_only)
+        yaml << " proxy-only";
+
+    if (options.no_query)
+        yaml << " no-query";
+
+    if (options.background_ping)
+        yaml << " background-ping";
+
+    if (options.no_digest)
+        yaml << " no-digest";
+
+    if (options.default_parent)
+        yaml << " default";
+
+    if (options.roundrobin)
+        yaml << " round-robin";
+
+    if (options.carp)
+        yaml << " carp";
+
+#if USE_AUTH
+    if (options.userhash)
+        yaml << " userhash";
+#endif
+
+    if (options.sourcehash)
+        yaml << " sourcehash";
+
+    if (options.weighted_roundrobin)
+        yaml << " weighted-round-robin";
+
+    if (options.mcast_responder)
+        yaml << " multicast-responder";
+
+#if PEER_MULTICAST_SIBLINGS
+    if (options.mcast_siblings)
+        yaml << " multicast-siblings";
+#endif
+
+    if (weight != 1)
+        yaml << " weight=" << weight;
+
+    if (options.closest_only)
+        yaml << " closest-only";
+
+#if USE_HTCP
+    if (options.htcp)
+    {
+        std::vector<const char *> opts {};
+        if (options.htcp_oldsquid)
+            opts.push_back("oldsquid");
+        if (options.htcp_no_clr)
+            opts.push_back("no-clr");
+        if (options.htcp_no_purge_clr)
+            opts.push_back("no-purge-clr");
+        if (options.htcp_only_clr)
+            opts.push_back("only-clr");
+        yaml << AsList(opts).prefixedBy(" htcp=").delimitedBy(",");
+    }
+#endif
+
+    if (options.no_netdb_exchange)
+        yaml << " no-netdb-exchange";
+
+#if USE_DELAY_POOLS
+    if (options.no_delay)
+        yaml << " no-delay";
+#endif
+
+    if (login)
+        yaml << " login=" << login;
+
+    if (mcast.ttl > 0)
+        yaml << " ttl=" << mcast.ttl;
+
+    if (connect_timeout_raw > 0)
+        yaml << " connect-timeout=" << connect_timeout_raw;
+
+    if (connect_fail_limit != PEER_TCP_MAGIC_COUNT)
+        yaml << " connect-fail-limit=" << connect_fail_limit;
+
+#if USE_CACHE_DIGESTS
+    if (digest_url)
+        yaml << " digest-url=" << digest_url;
+#endif
+
+    if (options.allow_miss)
+        yaml << " allow-miss";
+
+    if (options.no_tproxy)
+        yaml << " no-tproxy";
+
+    if (max_conn > 0)
+        yaml << " max-conn=" << max_conn;
+
+    if (standby.limit > 0)
+        yaml << " standby=" << standby.limit;
+
+    if (options.originserver)
+        yaml << " originserver";
+
+    if (domain)
+        yaml << " forceddomain=" << domain;
+
+    if (connection_auth == 0)
+        yaml << " connection-auth=off";
+    else if (connection_auth == 1)
+        yaml << " connection-auth=on";
+    else if (connection_auth == 2)
+        yaml << " connection-auth=auto";
+
+    secure.dumpCfg(yaml, "tls-");
+}
+
+void
+CachePeer::reportStatistics (std::ostream& yaml)
+{
+    yaml <<
+       name << ":\n" <<
+       "  type: " << typeString() << '\n' <<
+       "  host: " << host << '/' << http_port << '/' << icp.port << '\n';
+    yaml << "  flags:";
+    dumpOptions(yaml);
+    yaml << '\n';
+
+    std::vector<Ip::Address> addr;
+    std::copy(addresses, addresses+n_addresses, std::back_inserter(addr));
+    yaml << "  addresses: [ " << AsList(addr).prefixedBy("\"").delimitedBy("\", \"").suffixedBy("\"") << " ]\n";
+
+    yaml << "  status: " << (neighborUp(this) ? "Up" : "Down") << '\n' <<
+       "  fetches: " << stats.fetches << '\n' <<
+       "  open connections: " << stats.conn_open << '\n' <<
+       "  average RTT: " << stats.rtt << " msec\n";
+
+    if (stats.last_query > 0) {
+        yaml << "  last query:" <<
+           (squid_curtime - stats.last_query) << " seconds ago\n";
+    }
+
+    if (stats.last_reply > 0) {
+        yaml << " last reply: " <<
+           (squid_curtime - stats.last_reply) << " seconds ago\n";
+    }
+
+    yaml << "  pings sent: "  << stats.pings_sent << '\n' <<
+       "  pings acked: " << stats.pings_acked << " " <<
+       Math::intPercent(stats.pings_acked, stats.pings_sent) << "%\n";
+
+    yaml << "  replies ignored: " << stats.ignored_replies << " " <<
+       Math::intPercent(stats.ignored_replies, stats.pings_acked) << "%\n";
+
+    auto sectionHeader = AtMostOnce("  histogram of pings acked:\n");
+
+#if USE_HTCP
+    if (options.htcp) {
+        yaml << sectionHeader;
+        yaml << "    htcp misses: " << htcp.counts[0] << " " << Math::intPercent(htcp.counts[0], stats.pings_acked) << "%\n"
+             << "    htcp hits: " << htcp.counts[1] << " " << Math::intPercent(htcp.counts[1], stats.pings_acked) << "%\n";
+    } else {
+#endif
+        for (auto op : WholeEnum<icp_opcode>()) {
+            if (icp.counts[op] == 0)
+                continue;
+
+            yaml << sectionHeader;
+            yaml << "    " <<
+               std::right << icp_opcode_str[op] << ": " <<
+               icp.counts[op] << " " <<
+               Math::intPercent(icp.counts[op], stats.pings_acked) << "%\n";
+        }
+#if USE_HTCP
+    }
+#endif
+
+    if (stats.last_connect_failure) {
+        yaml << "  last failed connection at: " <<
+           Time::FormatHttpd(stats.last_connect_failure) << '\n';
+    }
+
+    yaml << "  keep-alive ratio: " <<
+       Math::intPercent(stats.n_keepalives_recv, stats.n_keepalives_sent) << "%\n";
+
+}
+
+const char *
+CachePeer::typeString() const
+{
+    static const char *typeNames[] {
+        "non-peer",
+        "sibling",
+        "parent",
+        "multicast group"
+    };
+    return typeNames[type];
+}
+
 std::ostream &
 operator <<(std::ostream &os, const CachePeer &p)
 {

src/CachePeer.h

@@ -47,6 +47,15 @@ class CachePeer
     /// \returns the effective connect timeout for the given peer
     time_t connectTimeout() const;
 
+    /// output to stream a representation of the peer's statistics
+    void reportStatistics (std::ostream& s);
+
+    /// output to stream a representation of the peer's configuration options
+    void dumpOptions(std::ostream &) const;
+
+    /// return a c-string representation of the peer's type
+    const char *typeString() const;
+
     /// n-th cache_peer directive, starting with 1
     u_int index = 0;
 

src/cache_cf.cc

@@ -2093,11 +2093,13 @@ dump_peer(StoreEntry * entry, const char *name, const CachePeers *peers)
         storeAppendPrintf(entry, "%s %s %s %d %d name=%s",
                           name,
                           p->host,
-                          neighborTypeStr(p),
+                          p->typeString(),
                           p->http_port,
                           p->icp.port,
                           p->name);
-        dump_peer_options(entry, p);
+        PackableStream s(*entry);
+        p->dumpOptions(s);
+        s << "\n";
 
         if (p->access) {
             snprintf(xname, 128, "cache_peer_access %s", p->name);

src/enums.h

@@ -20,7 +20,7 @@ enum fd_type {
 };
 
 typedef enum {
-    PEER_NONE,
+    PEER_NONE = 0,
     PEER_SIBLING,
     PEER_PARENT,
     PEER_MULTICAST