MB-30041: Migrate audit and event descriptor to nlohmann::json

BenHuddleston · daverigby · commit 5a6eed4e0ea7 · 2018-10-08T15:01:01.000Z
Migrate the auditd eventdescriptor file to nlohmann::json and make the necessary changes to audit parsing to do so. Change-Id: I5847553adfd24abddbe65d0562fb2c2127bd059a Reviewed-on: http://review.couchbase.org/99887 Reviewed-by: Dave Rigby <daver@couchbase.com> Tested-by: Build Bot <build@couchbase.com>
diff --git a/auditd/src/audit.cc b/auditd/src/audit.cc
@@ -22,13 +22,14 @@
 #include "event.h"
 #include "eventdescriptor.h"
 
-#include <cJSON.h>
 #include <logger/logger.h>
 #include <memcached/isotime.h>
 #include <memcached/server_cookie_iface.h>
 #include <nlohmann/json.hpp>
 #include <platform/dirutils.h>
+#include <utilities/json_utilities.h>
 #include <utilities/logtags.h>
+
 #include <algorithm>
 #include <chrono>
 #include <cstring>
@@ -113,88 +114,66 @@ void AuditImpl::create_audit_event(uint32_t event_id, nlohmann::json& payload) {
             "Audit::create_audit_event: Invalid event identifier specified");
 }
 
-bool AuditImpl::add_event_descriptor(cJSON* event_ptr) {
-    if (event_ptr == nullptr) {
-        LOG_WARNING(
-                "Audit::add_event_descriptor: No JSON data "
-                "provided");
-        return false;
-    }
-
+bool AuditImpl::add_event_descriptor(const nlohmann::json& json) {
     try {
-        auto entry = std::make_unique<EventDescriptor>(event_ptr);
+        auto entry = std::make_unique<EventDescriptor>(json);
         events.insert(std::pair<uint32_t, std::unique_ptr<EventDescriptor>>(
                 entry->getId(), std::move(entry)));
         return true;
     } catch (const std::bad_alloc&) {
         LOG_WARNING(
                 "Audit::add_event_descriptor: Failed to allocate "
                 "memory");
-    } catch (const std::logic_error& le) {
-        LOG_WARNING(R"(Audit::add_event_descriptor: JSON key "{}" error)",
-                    le.what());
+    } catch (const nlohmann::json::exception& e) {
+        LOG_WARNING(
+                "Audit::add_event_descriptor: JSON parsing exception {}"
+                " for event {}",
+                cb::UserDataView(e.what()),
+                cb::UserDataView(json.dump()));
+    } catch (const std::invalid_argument& e) {
+        LOG_WARNING(
+                "Audit::add_event_descriptor: parsing exception {}"
+                " for event {}",
+                cb::UserDataView(e.what()),
+                cb::UserDataView(json.dump()));
     }
 
     return false;
 }
 
-bool AuditImpl::process_module_data_structures(cJSON* module) {
-    if (module == NULL) {
-        LOG_WARNING(
-                "Audit::process_module_data_structures: No JSON data provided "
-                "for module");
-        return false;
-    }
-    while (module != NULL) {
-        cJSON *mod_ptr = module->child;
-        if (mod_ptr == NULL) {
-            LOG_WARNING(
-                    "Audit::process_module_data_structures: No JSON data "
-                    "provided for child node");
+bool AuditImpl::process_module_data_structures(const nlohmann::json& json) {
+    for (const auto& event : json) {
+        if (!add_event_descriptor(event)) {
             return false;
         }
-        while (mod_ptr != NULL) {
-            cJSON *event_ptr;
-            switch (mod_ptr->type) {
-                case cJSON_Number:
-                case cJSON_String:
-                    break;
-                case cJSON_Array:
-                    event_ptr = mod_ptr->child;
-                    while (event_ptr != NULL) {
-                        if (!add_event_descriptor(event_ptr)) {
-                            return false;
-                        }
-                        event_ptr = event_ptr->next;
-                    }
-                    break;
-                default:
-                    LOG_WARNING("Audit: JSON unknown field error");
-                    return false;
-            }
-            mod_ptr = mod_ptr->next;
-        }
-        module = module->next;
     }
     return true;
 }
 
-bool AuditImpl::process_module_descriptor(cJSON* module_descriptor) {
+bool AuditImpl::process_module_descriptor(const nlohmann::json& json) {
     events.clear();
-    while(module_descriptor != NULL) {
-        switch (module_descriptor->type) {
-            case cJSON_Number:
-                break;
-            case cJSON_Array:
-                if (!process_module_data_structures(module_descriptor->child)) {
-                    return false;
-                }
-                break;
-            default:
-                LOG_WARNING("Audit: JSON unknown field error");
+    for (const auto& module_descriptor : json) {
+        auto events = cb::getOptionalJsonObject(module_descriptor, "events");
+        if (!events.is_initialized()) {
+            LOG_WARNING(
+                    "Audit::process_module_descriptor: \"events\""
+                    " field missing");
+            return false;
+        }
+        switch (events->type()) {
+        case nlohmann::json::value_t::number_integer:
+            break;
+        case nlohmann::json::value_t::array:
+            if (!process_module_data_structures(*events)) {
                 return false;
+            }
+            break;
+        default:
+            LOG_WARNING(
+                    "Audit:process_module_descriptor \"events\" field is not"
+                    " integer or array");
+            return false;
         }
-        module_descriptor = module_descriptor->next;
     }
     return true;
 }
@@ -253,20 +232,25 @@ bool AuditImpl::configure() {
     if (str.empty()) {
         return false;
     }
-    cJSON *json_ptr = cJSON_Parse(str.c_str());
-    if (json_ptr == NULL) {
+
+    nlohmann::json events_json;
+    try {
+        events_json = nlohmann::json::parse(str);
+    } catch (const nlohmann::json::exception& e) {
         LOG_WARNING(
-                R"(Audit::configure: JSON parsing error of "{}" with the content: "{}")",
+                R"(Audit::configure: JSON parsing error of "{}" with the
+                   content: "{}", e.what(): {})",
                 audit_events_file,
-                cb::UserDataView(str));
+                cb::UserDataView(str),
+                cb::UserDataView(e.what()));
         return false;
     }
-    if (!process_module_descriptor(json_ptr->child)) {
-        cJSON_Delete(json_ptr);
+
+    auto modules = cb::getOptionalJsonObject(
+            events_json, "modules", nlohmann::json::value_t::array);
+    if (!modules.is_initialized() || !process_module_descriptor(*modules)) {
         return false;
     }
-    cJSON_Delete(json_ptr);
-
     auditfile.reconfigure(config);
 
     // iterate through the events map and update the sync and enabled flags
diff --git a/auditd/src/audit.h b/auditd/src/audit.h
@@ -90,10 +90,10 @@ class AuditImpl : public cb::audit::Audit {
      * @param event_ptr the definition of the descriptor in JSON
      * @return true if the descriptor was successfully added
      */
-    bool add_event_descriptor(cJSON* event_ptr);
+    bool add_event_descriptor(const nlohmann::json& json);
 
-    bool process_module_data_structures(cJSON* module);
-    bool process_module_descriptor(cJSON* module_descriptor);
+    bool process_module_data_structures(const nlohmann::json& json);
+    bool process_module_descriptor(const nlohmann::json& json);
 
     /**
      * Create an internal audit event structure
diff --git a/auditd/src/auditfile.cc b/auditd/src/auditfile.cc
@@ -17,7 +17,7 @@
 #include "auditfile.h"
 #include "audit.h"
 #include <JSON_checker.h>
-#include <cJSON.h>
+#include <cJSON_utils.h>
 #include <logger/logger.h>
 #include <memcached/isotime.h>
 #include <nlohmann/json.hpp>
diff --git a/auditd/src/eventdescriptor.cc b/auditd/src/eventdescriptor.cc
@@ -15,75 +15,54 @@
  *   limitations under the License.
  */
 #include "eventdescriptor.h"
+
+#include <utilities/json_utilities.h>
+
+#include <boost/optional.hpp>
 #include <stdexcept>
 
-EventDescriptor::EventDescriptor(const cJSON* root)
-    : id(uint32_t(locate(root, "id", cJSON_Number)->valueint)),
-      name(locate(root, "name", cJSON_String)->valuestring),
-      description(locate(root, "description", cJSON_String)->valuestring),
-      sync(locate(root, "sync", cJSON_True)->type == cJSON_True),
-      enabled(locate(root, "enabled", cJSON_True)->type == cJSON_True),
+EventDescriptor::EventDescriptor(const nlohmann::json& root)
+    : id(root.at("id").get<uint32_t>()),
+      name(root.at("name").get<std::string>()),
+      description(root.at("description").get<std::string>()),
+      sync(root.at("sync").get<bool>()),
+      enabled(root.at("enabled").get<bool>()),
       filteringPermitted(false) {
+    size_t expected = 5;
 
-    int expected = 5;
     // Look for the optional parameter filtering_permitted
-    cJSON* obj = cJSON_GetObjectItem(const_cast<cJSON*>(root), "filtering_permitted");
-    // If filter_permitted parameter is defined then set to appropriate value.
-    if (obj != nullptr) {
-        filteringPermitted = (obj->type == cJSON_True);
-        expected++;
-    }
+    filteringPermitted = root.value("filtering_permitted", false);
+    expected += root.count("filtering_permitted");
 
-    if ((obj = cJSON_GetObjectItem(const_cast<cJSON*>(root),
-                                   "mandatory_fields")) != nullptr) {
-        if (obj->type != cJSON_Array && obj->type != cJSON_Object) {
-            throw std::logic_error(
-                "EventDescriptor::EventDescriptor: Invalid type for mandatory_fields");
+    auto obj = cb::getOptionalJsonObject(root, "mandatory_fields");
+    if (obj.is_initialized()) {
+        if ((*obj).type() != nlohmann::json::value_t::array &&
+            (*obj).type() != nlohmann::json::value_t::object) {
+            throw std::invalid_argument(
+                    "EventDescriptor::EventDescriptor: "
+                    "Invalid type for mandatory_fields");
+        } else {
+            expected++;
         }
-        ++expected;
     }
-    if ((obj = cJSON_GetObjectItem(const_cast<cJSON*>(root),
-                                   "optional_fields")) != nullptr) {
-        if (obj->type != cJSON_Array && obj->type != cJSON_Object) {
-            throw std::logic_error(
-                "EventDescriptor::EventDescriptor: Invalid type for optional_fields");
-        }
-        ++expected;
-    }
-
-    if (expected != cJSON_GetArraySize(const_cast<cJSON*>(root))) {
-        throw std::logic_error(
-            "EventDescriptor::EventDescriptor: Unknown elements specified");
 
-    }
-}
-
-const cJSON* EventDescriptor::locate(const cJSON* root,
-                                     const char* field,
-                                     int type) {
-    const cJSON* ret = cJSON_GetObjectItem(const_cast<cJSON*>(root), field);
-    if (ret == nullptr) {
-        std::string msg("EventDescriptor::locate: Element \"");
-        msg.append(field);
-        msg.append("\" not found");
-        throw std::logic_error(msg);
-    }
-
-    if (type == cJSON_True) {
-        if (ret->type != cJSON_True && ret->type != cJSON_False) {
-            std::string msg("EventDescriptor::locate: Element \"");
-            msg.append(field);
-            msg.append("\" is not of the expected type");
-            throw std::logic_error(msg);
-        }
-    } else {
-        if (ret->type != type) {
-            std::string msg("EventDescriptor::locate: Element \"");
-            msg.append(field);
-            msg.append("\" is not of the expected type");
-            throw std::logic_error(msg);
+    obj = cb::getOptionalJsonObject(root, "optional_fields");
+    if (obj.is_initialized()) {
+        if ((*obj).type() != nlohmann::json::value_t::array &&
+            (*obj).type() != nlohmann::json::value_t::object) {
+            throw std::invalid_argument(
+                    "EventDescriptor::EventDescriptor: "
+                    "Invalid type for optional_fields");
+        } else {
+            expected++;
         }
     }
 
-    return ret;
+    if (expected != root.size()) {
+        throw std::invalid_argument(
+                "EventDescriptor::EventDescriptor: "
+                "Unknown elements specified. Number expected:" +
+                std::to_string(expected) +
+                " actual:" + std::to_string(root.size()));
+    }
 }
diff --git a/auditd/src/eventdescriptor.h b/auditd/src/eventdescriptor.h
@@ -16,8 +16,8 @@
  */
 #pragma once
 
+#include <nlohmann/json_fwd.hpp>
 #include <string>
-#include <cJSON_utils.h>
 
 /**
  * The EventDescriptor class represents a single event descriptor and
@@ -32,10 +32,10 @@ class EventDescriptor {
      * descriptor.
      *
      * @param root pointer to the json represenatation
-     * @throws std::logic_error if called with a JSON representation which
+     * @throws std::invalid_argument if called with a JSON representation which
      *         isn't what we expect
      */
-    EventDescriptor(const cJSON* root);
+    EventDescriptor(const nlohmann::json& root);
 
     const uint32_t getId() const {
         return id;
@@ -70,20 +70,6 @@ class EventDescriptor {
     }
 
 protected:
-    /**
-     * Locate the given field in the JSON
-     *
-     * @param root pointer to the first entry
-     * @param field the name of the field to locate
-     * @param type the expected type of the object (Note: there is no
-     *             cJSON_Bool #define, so you have to pass in cJSON_True
-     *             for that).
-     * @return the cJSON element for the object
-     * @throws std::logic_error if the field is missing or is of an
-     *         incorrect type
-     */
-    const cJSON* locate(const cJSON* root, const char* field, int type);
-
     const uint32_t id;
     const std::string name;
     const std::string description;
diff --git a/auditd/tests/CMakeLists.txt b/auditd/tests/CMakeLists.txt
@@ -43,7 +43,8 @@ ADD_TEST(NAME memcached-auditd-test
 ADD_EXECUTABLE(memcached_audit_evdescr_test eventdescriptor_test.cc
                ${Memcached_SOURCE_DIR}/auditd/src/eventdescriptor.cc
                ${Memcached_SOURCE_DIR}/auditd/src/eventdescriptor.h)
-TARGET_LINK_LIBRARIES(memcached_audit_evdescr_test cJSON gtest gtest_main)
+TARGET_LINK_LIBRARIES(memcached_audit_evdescr_test cJSON gtest gtest_main
+        mcd_util)
 ADD_TEST(NAME memcached-audit-evdescr-test
          WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
          COMMAND memcached_audit_evdescr_test)
diff --git a/auditd/tests/eventdescriptor_test.cc b/auditd/tests/eventdescriptor_test.cc
diff --git a/auditd/tests/testauditd.cc b/auditd/tests/testauditd.cc
