MB-30041: Migrate client_connection_map to nlohmann::json

Change-Id: I17beac8275c29c6a6c250465c744735ba95d524e
Reviewed-on: http://review.couchbase.org/104254
Tested-by: Build Bot <[email protected]>
Reviewed-by: Trond Norbye <[email protected]>

Author: BenHuddleston

protocol/connection/client_connection_map.cc

@@ -16,6 +16,9 @@
  */
 #include "client_connection_map.h"
 
+#include <nlohmann/json.hpp>
+#include <utilities/json_utilities.h>
+
 /////////////////////////////////////////////////////////////////////////
 // Implementation of the ConnectionMap class
 /////////////////////////////////////////////////////////////////////////
@@ -41,63 +44,38 @@ bool ConnectionMap::contains(bool ssl, sa_family_t family) {
     }
 }
 
-void ConnectionMap::initialize(cJSON* ports) {
+void ConnectionMap::initialize(const nlohmann::json& ports) {
     invalidate();
-    cJSON* array = cJSON_GetObjectItem(ports, "ports");
-    if (array == nullptr) {
-        std::string msg("ports not found in portnumber file: ");
-        msg.append(to_string(ports, false));
-        throw std::runtime_error(msg);
+    auto array = ports.find("ports");
+    if (array == ports.end()) {
+        throw std::runtime_error("ports not found in portnumber file: " +
+                                 ports.dump());
     }
 
-    auto numEntries = cJSON_GetArraySize(array);
     sa_family_t family;
-    for (int ii = 0; ii < numEntries; ++ii) {
-        auto obj = cJSON_GetArrayItem(array, ii);
-        auto fam = cJSON_GetObjectItem(obj, "family");
-        if (strcmp(fam->valuestring, "AF_INET") == 0) {
+    for (const auto obj : *array) {
+        // auto fam = port.find("family");
+        auto fam = cb::jsonGet<std::string>(obj, "family");
+        if (fam == "AF_INET") {
             family = AF_INET;
-        } else if (strcmp(fam->valuestring, "AF_INET6") == 0) {
-            family = AF_INET6;
         } else {
-            std::string msg("Unsupported network family: ");
-            msg.append(to_string(obj, false));
-            throw std::runtime_error(msg);
-        }
-
-        auto ssl = cJSON_GetObjectItem(obj, "ssl");
-        if (ssl == nullptr) {
-            std::string msg("ssl missing for entry: ");
-            msg.append(to_string(obj, false));
-            throw std::runtime_error(msg);
-        }
-
-        auto port = cJSON_GetObjectItem(obj, "port");
-        if (port == nullptr) {
-            std::string msg("port missing for entry: ");
-            msg.append(to_string(obj, false));
-            throw std::runtime_error(msg);
-        }
-
-        auto protocol = cJSON_GetObjectItem(obj, "protocol");
-        if (protocol == nullptr) {
-            std::string msg("protocol missing for entry: ");
-            msg.append(to_string(obj, false));
-            throw std::runtime_error(msg);
+            family = AF_INET6;
         }
 
-        auto portval = static_cast<in_port_t>(port->valueint);
-        bool useSsl = ssl->type == cJSON_True ? true : false;
+        auto ssl = cb::jsonGet<bool>(obj, "ssl");
+        auto port = cb::jsonGet<size_t>(obj, "port");
+        auto protocol = cb::jsonGet<std::string>(obj, "protocol");
 
         MemcachedConnection* connection;
-        if (strcmp(protocol->valuestring, "memcached") != 0) {
+        if (protocol != "memcached") {
             throw std::logic_error(
                     "ConnectionMap::initialize: Invalid value passed for "
                     "protocol: " +
-                    std::string(protocol->valuestring));
+                    std::string(protocol));
         }
 
-        connection = new MemcachedConnection("", portval, family, useSsl);
+        auto portVal = static_cast<in_port_t>(port);
+        connection = new MemcachedConnection("", portVal, family, ssl);
         connections.push_back(std::unique_ptr<MemcachedConnection>{connection});
     }
 }

protocol/connection/client_connection_map.h

@@ -17,15 +17,16 @@
 #pragma once
 
 #include "client_connection.h"
-#include <cJSON_utils.h>
+
+#include <nlohmann/json_fwd.hpp>
 
 class ConnectionMap {
 public:
     /**
      * Initialize the connection map with connections matching the ports
      * opened from Memcached
      */
-    void initialize(cJSON* ports);
+    void initialize(const nlohmann::json& ports);
 
     /**
      * Invalidate all of the connections

tests/testapp/testapp.cc

@@ -23,6 +23,7 @@
 
 #include <include/memcached/protocol_binary.h>
 #include <nlohmann/json.hpp>
+#include <utilities/json_utilities.h>
 #include <atomic>
 #include <csignal>
 #include <thread>
@@ -458,22 +459,6 @@ void write_config_to_file(const std::string& config, const std::string& fname) {
     }
 }
 
-/**
- * Load and parse the content of a file into a cJSON array
- *
- * @param file the name of the file
- * @return the decoded cJSON representation
- * @throw a string if something goes wrong
- */
-static unique_cJSON_ptr loadJsonFile(const std::string& file) {
-    unique_cJSON_ptr ret(cJSON_Parse(cb::io::loadFile(file).c_str()));
-    if (ret.get() == nullptr) {
-        throw std::logic_error("Failed to parse: " + file);
-    }
-
-    return ret;
-}
-
 void TestappTest::verify_server_running() {
     if (embedded_memcached_server) {
         // we don't monitor this thread...
@@ -551,43 +536,37 @@ void TestappTest::parse_portnumber_file(in_port_t& port_out,
     port_out = (in_port_t)-1;
     ssl_port_out = (in_port_t)-1;
 
-    unique_cJSON_ptr portnumbers;
-    portnumbers = loadJsonFile(portnumber_file);
-    ASSERT_NE(nullptr, portnumbers);
-    connectionMap.initialize(portnumbers.get());
-
-    cJSON* array = cJSON_GetObjectItem(portnumbers.get(), "ports");
-    ASSERT_NE(nullptr, array) << "ports not found in portnumber file";
+    // We'll throw here if anything goes wrong
+    const nlohmann::json portnumbers =
+            nlohmann::json::parse(cb::io::loadFile(portnumber_file));
 
-    auto numEntries = cJSON_GetArraySize(array);
-    for (int ii = 0; ii < numEntries; ++ii) {
-        auto obj = cJSON_GetArrayItem(array, ii);
+    connectionMap.initialize(portnumbers);
 
-        auto protocol = cJSON_GetObjectItem(obj, "protocol");
-        if (strcmp(protocol->valuestring, "memcached") != 0) {
+    auto array = portnumbers["ports"];
+    for (auto obj : array) {
+        auto proto = obj.find("protocol");
+        if (proto == obj.end() || proto->get<std::string>() != "memcached") {
             // the new test use the connectionmap
             continue;
         }
 
-        auto family = cJSON_GetObjectItem(obj, "family");
-        if (strcmp(family->valuestring, "AF_INET") != 0) {
+        auto fam = obj.find("family");
+        if (fam == obj.end() || fam->get<std::string>() != "AF_INET") {
             // For now we don't test IPv6
             continue;
         }
-        auto ssl = cJSON_GetObjectItem(obj, "ssl");
-        ASSERT_NE(nullptr, ssl);
-        auto port = cJSON_GetObjectItem(obj, "port");
-        ASSERT_NE(nullptr, port);
-
-        in_port_t* out_port;
-        if (ssl->type == cJSON_True) {
-            out_port = &ssl_port_out;
+
+        auto ssl = cb::jsonGet<bool>(obj, "ssl");
+        auto port = cb::jsonGet<size_t>(obj, "port");
+
+        in_port_t* outPort;
+        if (ssl) {
+            outPort = &ssl_port_out;
         } else {
-            out_port = &port_out;
+            outPort = &port_out;
         }
-        *out_port = static_cast<in_port_t>(port->valueint);
+        *outPort = static_cast<in_port_t>(port);
     }
-
     EXPECT_EQ(0, remove(portnumber_file.c_str()));
 }
 

tests/testapp/testapp_audit.cc

@@ -21,11 +21,14 @@
 
 #include "testapp.h"
 
-#include <platform/dirutils.h>
 #include "testapp_client_test.h"
 #include "memcached_audit_events.h"
 #include "auditd/auditd_audit_events.h"
 
+#include <cJSON.h>
+#include <cJSON_utils.h>
+#include <platform/dirutils.h>
+
 #include <fstream>
 #include <string>
 #include <thread>

tests/testapp/testapp_cmd_timers.cc

@@ -18,6 +18,8 @@
 #include "testapp.h"
 #include "testapp_client_test.h"
 
+#include <cJSON.h>
+#include <cJSON_utils.h>
 #include <platform/compress.h>
 #include <protocol/connection/client_connection.h>
 #include <algorithm>

tests/testapp/testapp_errmap.cc

@@ -18,6 +18,8 @@
 #include "testapp.h"
 #include "testapp_client_test.h"
 
+#include <cJSON.h>
+#include <cJSON_utils.h>
 
 class ErrmapTest : public TestappClientTest {
 public:

tests/testapp/testapp_subdoc.cc

@@ -24,6 +24,7 @@
 #include "testapp_subdoc_common.h"
 
 #include <cJSON.h>
+#include <cJSON_utils.h>
 #include <memcached/protocol_binary.h>
 #include <memcached/util.h> // for memcached_protocol_errcode_2_text()
 #include <platform/cb_malloc.h>

tests/testapp/testapp_subdoc_multipath.cc

@@ -21,6 +21,9 @@
 
 #include "testapp_subdoc_common.h"
 
+#include <cJSON.h>
+#include <cJSON_utils.h>
+
 // Test multi-path lookup command - simple single SUBDOC_GET
 TEST_P(SubdocTestappTest, SubdocMultiLookup_GetSingle) {
     store_document("dict", "{\"key1\":1,\"key2\":\"two\", \"key3\":3.0}");