FCBIS v7.0

SConstruct

@@ -296,6 +296,12 @@ add_option(
     nargs=0,
 )
 
+add_option(
+    'enable-fcbis',
+    help='Enable file copy-based initial sync',
+    nargs=0,
+)
+
 add_option(
     'full-featured',
     help='Enable all optional features',
@@ -2716,6 +2722,10 @@ if has_option('enable-fipsmode') or has_option('full-featured'):
     env.SetConfigHeaderDefine("PERCONA_FIPSMODE_ENABLED")
     env['PSMDB_PRO_FEATURES'].append('FIPSMode')
 
+if has_option('enable-fcbis') or has_option('full-featured'):
+    env.SetConfigHeaderDefine("PERCONA_FCBIS_ENABLED")
+    env['PSMDB_PRO_FEATURES'].append('FCBIS')
+
 env.Tool('forceincludes')
 
 # ---- other build setup -----

src/mongo/SConscript

@@ -77,6 +77,7 @@ config_header_substs = (
     ('@mongo_config_wiredtiger_enabled@', 'MONGO_CONFIG_WIREDTIGER_ENABLED'),
     ('@mongo_config_grpc@', 'MONGO_CONFIG_GRPC'),
     ('@percona_fipsmode_enabled@', 'PERCONA_FIPSMODE_ENABLED'),
+    ('@percona_fcbis_enabled@', 'PERCONA_FCBIS_ENABLED'),
 )
 
 

src/mongo/config.h.in

@@ -112,3 +112,6 @@
 
 // FIPSMode enabled
 @percona_fipsmode_enabled@
+
+// FCBIS enabled
+@percona_fcbis_enabled@

src/mongo/db/SConscript

@@ -2519,6 +2519,7 @@ env.Library(
         'query/stats/stats',
         'repl/drop_pending_collection_reaper',
         'repl/initial_syncer',
+        'repl/initial_syncer_fcb' if has_option('enable-fcbis') or has_option('full-featured') else [],
         'repl/repl_coordinator_impl',
         'repl/replication_recovery',
         'repl/serveronly_repl',

src/mongo/db/pipeline/SConscript

@@ -244,6 +244,7 @@ env.Library(
     source=[
         'document_source_backup_cursor.cpp',
         'document_source_backup_cursor_extend.cpp',
+        'document_source_backup_file.cpp',
     ],
     LIBDEPS_PRIVATE=[
         '$BUILD_DIR/mongo/db/server_base',

src/mongo/db/pipeline/document_source_backup_cursor.h

@@ -59,7 +59,12 @@ class DocumentSourceBackupCursor : public DocumentSource {
             return true;
         }
 
-        void assertSupportsMultiDocumentTransaction() const {
+        ReadConcernSupportResult supportsReadConcern(repl::ReadConcernLevel level,
+                                                     bool isImplicitDefault) const final {
+            return onlyReadConcernLocalSupported(kStageName, level, isImplicitDefault);
+        }
+
+        void assertSupportsMultiDocumentTransaction() const final {
             transactionNotSupported(kStageName);
         }
     };

src/mongo/db/pipeline/document_source_backup_cursor_extend.h

@@ -59,7 +59,12 @@ class DocumentSourceBackupCursorExtend : public DocumentSource {
             return true;
         }
 
-        void assertSupportsMultiDocumentTransaction() const {
+        ReadConcernSupportResult supportsReadConcern(repl::ReadConcernLevel level,
+                                                     bool isImplicitDefault) const final {
+            return onlyReadConcernLocalSupported(kStageName, level, isImplicitDefault);
+        }
+
+        void assertSupportsMultiDocumentTransaction() const final {
             transactionNotSupported(kStageName);
         }
     };

src/mongo/db/pipeline/document_source_backup_file.cpp

@@ -0,0 +1,187 @@
+/*======
+This file is part of Percona Server for MongoDB.
+
+Copyright (C) 2024-present Percona and/or its affiliates. All rights reserved.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the Server Side Public License, version 1,
+    as published by MongoDB, Inc.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    Server Side Public License for more details.
+
+    You should have received a copy of the Server Side Public License
+    along with this program. If not, see
+    <http://www.mongodb.com/licensing/server-side-public-license>.
+
+    As a special exception, the copyright holders give permission to link the
+    code of portions of this program with the OpenSSL library under certain
+    conditions as described in each individual source file and distribute
+    linked combinations including the program with the OpenSSL library. You
+    must comply with the Server Side Public License in all respects for
+    all of the code used other than as permitted herein. If you modify file(s)
+    with this exception, you may extend this exception to your version of the
+    file(s), but you are not obligated to do so. If you do not wish to do so,
+    delete this exception statement from your version. If you delete this
+    exception statement from all source files in the program, then also delete
+    it in the license file.
+======= */
+
+#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery
+
+#include "mongo/db/pipeline/document_source_backup_file.h"
+
+#include <array>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "mongo/base/data_range.h"
+#include "mongo/base/error_codes.h"
+#include "mongo/base/string_data.h"
+#include "mongo/bson/bsonmisc.h"
+#include "mongo/bson/bsonobj.h"
+#include "mongo/bson/bsontypes.h"
+#include "mongo/db/exec/document_value/document.h"
+#include "mongo/db/namespace_string.h"
+#include "mongo/util/assert_util.h"
+#include "mongo/util/intrusive_counter.h"
+#include "mongo/util/str.h"
+#include "mongo/util/uuid.h"
+
+namespace mongo {
+
+namespace {
+constexpr StringData kBackupId = "backupId"_sd;
+constexpr StringData kFile = "file"_sd;
+constexpr StringData kByteOffset = "byteOffset"_sd;
+
+// We only link this file into mongod so this stage doesn't exist in mongos
+REGISTER_INTERNAL_DOCUMENT_SOURCE(_backupFile,
+                                  DocumentSourceBackupFile::LiteParsed::parse,
+                                  DocumentSourceBackupFile::createFromBson,
+                                  true);
+}  // namespace
+
+using boost::intrusive_ptr;
+
+std::unique_ptr<DocumentSourceBackupFile::LiteParsed> DocumentSourceBackupFile::LiteParsed::parse(
+    const NamespaceString& nss, const BSONElement& spec) {
+
+    return std::make_unique<DocumentSourceBackupFile::LiteParsed>(spec.fieldName());
+}
+
+const char* DocumentSourceBackupFile::getSourceName() const {
+    return kStageName.rawData();
+}
+
+Value DocumentSourceBackupFile::serialize(const SerializationOptions& opts) const {
+    return Value{Document{{getSourceName(),
+                           Document{{kBackupId, Value(_backupId)},
+                                    {kFile, Value(_filePath)},
+                                    {kByteOffset, Value(_byteOffset)}}}}};
+}
+
+DocumentSource::GetNextResult DocumentSourceBackupFile::doGetNext() {
+    if (_file.eof()) {
+        return GetNextResult::makeEOF();
+    }
+
+    auto byteOffset = _file.tellg();
+    _file.read(_dataBuf.data(), kBlockSize);
+    uassert(ErrorCodes::FileStreamFailed,
+            str::stream() << "Error reading file " << _filePath << " at offset " << byteOffset,
+            !_file.bad());
+    auto bytesRead = _file.gcount();
+    auto eof = _file.eof();
+
+    Document doc;
+    doc = Document{{"byteOffset"_sd, static_cast<long long>(byteOffset)},
+                   {"data"_sd, BSONBinData(_dataBuf.data(), bytesRead, BinDataGeneral)},
+                   {"endOfFile"_sd, eof}};
+
+    return doc;
+}
+
+intrusive_ptr<DocumentSource> DocumentSourceBackupFile::createFromBson(
+    BSONElement spec, const intrusive_ptr<ExpressionContext>& pExpCtx) {
+    // This cursor is non-tailable so we don't touch pExpCtx->tailableMode here
+
+    uassert(ErrorCodes::FailedToParse,
+            str::stream() << kStageName << " parameters must be specified in an object, but found: "
+                          << typeName(spec.type()),
+            spec.type() == Object);
+
+    auto backupId = UUID::fromCDR(std::array<unsigned char, UUID::kNumBytes>{});
+    std::string filePath;
+    long long byteOffset = 0;
+
+    for (auto&& elem : spec.embeddedObject()) {
+        const auto fieldName = elem.fieldNameStringData();
+
+        if (fieldName == kBackupId) {
+            uassert(ErrorCodes::TypeMismatch,
+                    str::stream() << "The '" << fieldName << "' parameter of the " << kStageName
+                                  << " stage must be a binary data value, but found: "
+                                  << typeName(elem.type()),
+                    elem.type() == BSONType::BinData);
+            backupId = uassertStatusOK(UUID::parse(elem));
+        } else if (fieldName == kFile) {
+            uassert(ErrorCodes::TypeMismatch,
+                    str::stream() << "The '" << fieldName << "' parameter of the " << kStageName
+                                  << " stage must be a string value, but found: "
+                                  << typeName(elem.type()),
+                    elem.type() == BSONType::String);
+            filePath = elem.String();
+        } else if (fieldName == kByteOffset) {
+            uassert(ErrorCodes::TypeMismatch,
+                    str::stream() << "The '" << fieldName << "' parameter of the " << kStageName
+                                  << " stage must be a long integer value, but found: "
+                                  << typeName(elem.type()),
+                    elem.type() == BSONType::NumberLong);
+            byteOffset = elem.Long();
+        } else {
+            uasserted(ErrorCodes::FailedToParse,
+                      str::stream() << "Unrecognized option '" << fieldName << "' in " << kStageName
+                                    << " stage");
+        }
+    }
+
+    uassert(ErrorCodes::InvalidOptions,
+            str::stream() << "'" << kByteOffset << "' parameter cannot be less than zero",
+            byteOffset >= 0);
+
+    std::ifstream iFile(filePath, std::ios_base::in | std::ios_base::binary);
+    uassert(ErrorCodes::FileOpenFailed,
+            str::stream() << "Failed to open file " << filePath,
+            iFile.is_open());
+    iFile.seekg(byteOffset);
+    uassert(ErrorCodes::FileOpenFailed,
+            str::stream() << "Failed to set read position " << byteOffset << " in file "
+                          << filePath,
+            !iFile.fail());
+    invariant(byteOffset == iFile.tellg());
+
+    return make_intrusive<DocumentSourceBackupFile>(
+        pExpCtx, backupId, std::move(filePath), byteOffset, std::move(iFile));
+}
+
+DocumentSourceBackupFile::DocumentSourceBackupFile(const intrusive_ptr<ExpressionContext>& expCtx,
+                                                   UUID backupId,
+                                                   std::string filePath,
+                                                   long long byteOffset,
+                                                   std::ifstream file)
+    : DocumentSource(kStageName, expCtx),
+      _dataBuf(),
+      _backupId(backupId),
+      _filePath(std::move(filePath)),
+      _byteOffset(byteOffset),
+      _file(std::move(file)) {}
+
+DocumentSourceBackupFile::~DocumentSourceBackupFile() {
+    _file.close();
+}
+
+}  // namespace mongo