MB-45505: Move system event types to own module

Moving code to own module to remove a cyclic dependency in
an upstream change.

Change-Id: I4bd371b293f9144ded5423c8f45fe24ace4e1b41
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/150933
Reviewed-by: James Harrison <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: jimwwalker

engines/ep/CMakeLists.txt

@@ -246,6 +246,7 @@ SET(COLLECTIONS_SOURCE src/collections/collections_types.cc
                        ${CMAKE_CURRENT_BINARY_DIR}/src/collections/kvstore_generated.h
                        ${CMAKE_CURRENT_BINARY_DIR}/src/collections/manifest_generated.h
                        src/collections/scan_context.cc
+                       src/collections/system_event_types.cc
                        src/collections/vbucket_filter.cc
                        src/collections/vbucket_manifest.cc
                        src/collections/vbucket_manifest_entry.cc

engines/ep/src/collections/collections_types.cc

@@ -77,41 +77,6 @@ AccumulatedStats& AccumulatedStats::operator+=(const AccumulatedStats& other) {
     return *this;
 }
 
-std::string to_string(const CreateEventData& event) {
-    return fmt::format(
-            fmt("CreateCollection{{uid:{:#x} scopeID:{} collectionID:{} "
-                "name:'"
-                "{}' maxTTLEnabled:{} maxTTL:{}}}"),
-            event.manifestUid.load(),
-            event.metaData.sid.to_string(),
-            event.metaData.cid.to_string(),
-            event.metaData.name,
-            event.metaData.maxTtl.has_value(),
-            event.metaData.maxTtl.has_value() ? event.metaData.maxTtl->count()
-                                              : 0);
-}
-
-std::string to_string(const DropEventData& event) {
-    return fmt::format(
-            fmt("DropCollection{{uid:{:#x} scopeID:{} collectionID:{}}}"),
-            event.manifestUid.load(),
-            event.sid.to_string(),
-            event.cid.to_string());
-}
-
-std::string to_string(const CreateScopeEventData& event) {
-    return fmt::format(fmt("CreateScope{{uid:{:#x} scopeID:{} name:'{}'}}"),
-                       event.manifestUid.load(),
-                       event.metaData.sid.to_string(),
-                       event.metaData.name);
-}
-
-std::string to_string(const DropScopeEventData& event) {
-    return fmt::format(fmt("DropScope{{uid:{:#x} scopeID:{}}}"),
-                       event.manifestUid.load(),
-                       event.sid.to_string());
-}
-
 namespace VB {
 std::string to_string(ManifestUpdateStatus status) {
     switch (status) {

engines/ep/src/collections/collections_types.h

@@ -162,7 +162,7 @@ struct CollectionMetaData {
 /**
  * The metadata of a single scope
  *
- * Default construction yields the default collection
+ * Default construction yields the default scope
  */
 struct ScopeMetaData {
     ScopeID sid{ScopeID::Default}; // The scope's ID
@@ -173,137 +173,6 @@ struct ScopeMetaData {
     }
 };
 
-/**
- * All of the data a system event needs
- */
-struct CreateEventData {
-    ManifestUid manifestUid; // The Manifest which generated the event
-    CollectionMetaData metaData; // The data of the new collection
-};
-
-struct DropEventData {
-    ManifestUid manifestUid; // The Manifest which generated the event
-    ScopeID sid; // The scope that the collection belonged to
-    CollectionID cid; // The collection the event belongs to
-};
-
-struct CreateScopeEventData {
-    ManifestUid manifestUid; // The Manifest which generated the event
-    ScopeMetaData metaData; // The data of the new scope
-};
-
-struct DropScopeEventData {
-    ManifestUid manifestUid; // The Manifest which generated the event
-    ScopeID sid; // The scope the event belongs to
-};
-
-std::string to_string(const CreateEventData& event);
-std::string to_string(const DropEventData& event);
-std::string to_string(const CreateScopeEventData& event);
-std::string to_string(const DropScopeEventData& event);
-
-/**
- * All of the data a DCP create event message will transmit in the value of the
- * message. This is the layout to be used on the wire and is in the correct
- * byte order
- */
-struct CreateEventDcpData {
-    explicit CreateEventDcpData(const CreateEventData& ev)
-        : manifestUid(ev.manifestUid),
-          sid(ev.metaData.sid),
-          cid(ev.metaData.cid) {
-    }
-    /// The manifest uid stored in network byte order ready for sending
-    ManifestUidNetworkOrder manifestUid;
-    /// The scope id stored in network byte order ready for sending
-    ScopeIDNetworkOrder sid;
-    /// The collection id stored in network byte order ready for sending
-    CollectionIDNetworkOrder cid;
-    // The size is sizeof(manifestUid) + sizeof(cid) + sizeof(sid)
-    // (msvc won't allow that expression)
-    constexpr static size_t size{16};
-};
-
-/**
- * All of the data a DCP create event message will transmit in the value of a
- * DCP system event message (when the collection is created with a TTL). This is
- * the layout to be used on the wire and is in the correct byte order
- */
-struct CreateWithMaxTtlEventDcpData {
-    explicit CreateWithMaxTtlEventDcpData(const CreateEventData& ev)
-        : manifestUid(ev.manifestUid),
-          sid(ev.metaData.sid),
-          cid(ev.metaData.cid),
-          maxTtl(htonl(gsl::narrow_cast<uint32_t>(
-                  ev.metaData.maxTtl.value().count()))) {
-    }
-    /// The manifest uid stored in network byte order ready for sending
-    ManifestUidNetworkOrder manifestUid;
-    /// The scope id stored in network byte order ready for sending
-    ScopeIDNetworkOrder sid;
-    /// The collection id stored in network byte order ready for sending
-    CollectionIDNetworkOrder cid;
-    /// The collection's maxTTL value (in network byte order)
-    uint32_t maxTtl;
-    // The size is sizeof(manifestUid) + sizeof(cid) + sizeof(sid) +
-    //             sizeof(maxTTL) (msvc won't allow that expression)
-    constexpr static size_t size{20};
-};
-
-/**
- * All of the data a DCP drop event message will transmit in the value of the
- * message. This is the layout to be used on the wire and is in the correct
- * byte order
- */
-struct DropEventDcpData {
-    explicit DropEventDcpData(const DropEventData& data)
-        : manifestUid(data.manifestUid), sid(data.sid), cid(data.cid) {
-    }
-
-    /// The manifest uid stored in network byte order ready for sending
-    ManifestUidNetworkOrder manifestUid;
-    /// The scope id stored in network byte order ready for sending
-    ScopeIDNetworkOrder sid;
-    /// The collection id stored in network byte order ready for sending
-    CollectionIDNetworkOrder cid;
-    // The size is sizeof(manifestUid) + sizeof(cid) (msvc won't allow that
-    // expression)
-    constexpr static size_t size{16};
-};
-
-/**
- * All of the data a DCP create scope event message will transmit in the value
- * of the message. This is the layout to be used on the wire and is in the
- * correct byte order
- */
-struct CreateScopeEventDcpData {
-    explicit CreateScopeEventDcpData(const CreateScopeEventData& data)
-        : manifestUid(data.manifestUid), sid(data.metaData.sid) {
-    }
-    /// The manifest uid stored in network byte order ready for sending
-    ManifestUidNetworkOrder manifestUid;
-    /// The scope id stored in network byte order ready for sending
-    ScopeIDNetworkOrder sid;
-    constexpr static size_t size{12};
-};
-
-/**
- * All of the data a DCP drop scope event message will transmit in the value of
- * the message. This is the layout to be used on the wire and is in the correct
- * byte order
- */
-struct DropScopeEventDcpData {
-    explicit DropScopeEventDcpData(const DropScopeEventData& data)
-        : manifestUid(data.manifestUid), sid(data.sid) {
-    }
-
-    /// The manifest uid stored in network byte order ready for sending
-    ManifestUidNetworkOrder manifestUid;
-    /// The collection id stored in network byte order ready for sending
-    ScopeIDNetworkOrder sid;
-    constexpr static size_t size{12};
-};
-
 /**
  * For creation of collection SystemEvents - The SystemEventFactory
  * glues the CollectionID into the event key (so create of x doesn't

engines/ep/src/collections/system_event_types.cc

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021 Couchbase, Inc
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "collections/system_event_types.h"
+
+#include <spdlog/fmt/fmt.h>
+
+namespace Collections {
+
+std::string to_string(const CreateEventData& event) {
+    return fmt::format(
+            fmt("CreateCollection{{uid:{:#x} scopeID:{} collectionID:{} "
+                "name:'"
+                "{}' maxTTLEnabled:{} maxTTL:{}}}"),
+            event.manifestUid.load(),
+            event.metaData.sid.to_string(),
+            event.metaData.cid.to_string(),
+            event.metaData.name,
+            event.metaData.maxTtl.has_value(),
+            event.metaData.maxTtl.has_value() ? event.metaData.maxTtl->count()
+                                              : 0);
+}
+
+std::string to_string(const DropEventData& event) {
+    return fmt::format(
+            fmt("DropCollection{{uid:{:#x} scopeID:{} collectionID:{}}}"),
+            event.manifestUid.load(),
+            event.sid.to_string(),
+            event.cid.to_string());
+}
+
+std::string to_string(const CreateScopeEventData& event) {
+    return fmt::format(fmt("CreateScope{{uid:{:#x} scopeID:{} name:'{}'}}"),
+                       event.manifestUid.load(),
+                       event.metaData.sid.to_string(),
+                       event.metaData.name);
+}
+
+std::string to_string(const DropScopeEventData& event) {
+    return fmt::format(fmt("DropScope{{uid:{:#x} scopeID:{}}}"),
+                       event.manifestUid.load(),
+                       event.sid.to_string());
+}
+
+} // namespace Collections