github_pull_request_285284

Committed 21 Nov 2023 01:56PM UTC coverage: 91.664% (-0.03%) from 91.689%

Build # github_pull_request_285284

Build Type

Pull #7123

Evergreen

Committed by

jedelbo

Commit Message

Merge branch 'master' into jf/mql

Pull Request Pull Request #7123: PoC: Add MQL translation skeleton

Run Details

92364 of 169228 branches covered (0.0%)

264 of 308 new or added lines in 5 files covered. (85.71%)

102 existing lines in 21 files now uncovered.

231504 of 252558 relevant lines covered (91.66%)

5988933.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.32

/src/realm/sync/noinst/client_reset_operation.cpp

/*************************************************************************
 *
 * Copyright 2021 Realm 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 <realm/sync/noinst/client_reset_operation.hpp>

#include <realm/sync/history.hpp>
#include <realm/sync/noinst/client_history_impl.hpp>
#include <realm/sync/noinst/client_reset.hpp>
#include <realm/transaction.hpp>
#include <realm/util/scope_exit.hpp>

namespace realm::_impl::client_reset {

namespace {

constexpr static std::string_view c_fresh_suffix(".fresh");

} // namespace

std::string get_fresh_path_for(const std::string& path)
{
    const size_t suffix_len = c_fresh_suffix.size();
    REALM_ASSERT(path.length());
    REALM_ASSERT_DEBUG_EX(
        path.size() < suffix_len || path.substr(path.size() - suffix_len, suffix_len) != c_fresh_suffix, path);
    return path + c_fresh_suffix.data();
}

bool is_fresh_path(const std::string& path)
{
    const size_t suffix_len = c_fresh_suffix.size();
    REALM_ASSERT(path.length());
    if (path.size() < suffix_len) {
        return false;
    }
    return path.substr(path.size() - suffix_len, suffix_len) == c_fresh_suffix;
}

bool perform_client_reset(util::Logger& logger, DB& db, DB& fresh_db, ClientResyncMode mode,
                          CallbackBeforeType notify_before, CallbackAfterType notify_after,
                          sync::SaltedFileIdent new_file_ident, sync::SubscriptionStore* sub_store,
                          util::FunctionRef<void(int64_t)> on_flx_version, bool recovery_is_allowed)
{
    REALM_ASSERT(mode != ClientResyncMode::Manual);
    logger.debug("Possibly beginning client reset operation: realm_path = %1, mode = %2, recovery_allowed = %3",
                 db.get_path(), mode, recovery_is_allowed);

    auto always_try_clean_up = util::make_scope_exit([&]() noexcept {
        std::string path_to_clean = fresh_db.get_path();
        try {
            fresh_db.close();
            constexpr bool delete_lockfile = true;
            DB::delete_files(path_to_clean, nullptr, delete_lockfile);
        }
        catch (const std::exception& err) {
            logger.warn("In ClientResetOperation::finalize, the fresh copy '%1' could not be cleaned up due to "
                        "an exception: '%2'",
                        path_to_clean, err.what());
            // ignored, this is just a best effort
        }
    });

    // only do the reset if there is data to reset
    // if there is nothing in this Realm, then there is nothing to reset and
    // sync should be able to continue as normal
    auto latest_version = db.get_version_id_of_latest_snapshot();
    bool local_realm_exists = latest_version.version > 1;
    if (!local_realm_exists) {
        logger.debug("Local Realm file has never been written to, so skipping client reset.");
        return false;
    }

    VersionID frozen_before_state_version = notify_before ? notify_before() : latest_version;

    // If m_notify_after is set, pin the previous state to keep it around.
    TransactionRef previous_state;
    if (notify_after) {
        previous_state = db.start_frozen(frozen_before_state_version);
    }
    bool did_recover_out = false;
    client_reset::perform_client_reset_diff(db, fresh_db, new_file_ident, logger, mode, recovery_is_allowed,
                                            &did_recover_out, sub_store,
                                            on_flx_version); // throws

    if (notify_after) {
        notify_after(previous_state->get_version_of_current_transaction(), did_recover_out);
    }

    return true;
}

} // namespace realm::_impl::client_reset

1	/*************************************************************************
2	*
3	* Copyright 2021 Realm Inc.
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	**************************************************************************/
18
19	#include <realm/sync/noinst/client_reset_operation.hpp>
20
21	#include <realm/sync/history.hpp>
22	#include <realm/sync/noinst/client_history_impl.hpp>
23	#include <realm/sync/noinst/client_reset.hpp>
24	#include <realm/transaction.hpp>
25	#include <realm/util/scope_exit.hpp>
26
27	namespace realm::_impl::client_reset {
28
29	namespace {
30
31	constexpr static std::string_view c_fresh_suffix(".fresh");
32
33	} // namespace
34
35	std::string get_fresh_path_for(const std::string& path)
36	{	3,318,940✔
37	const size_t suffix_len = c_fresh_suffix.size();	3,318,940✔
38	REALM_ASSERT(path.length());	3,318,940✔
39	REALM_ASSERT_DEBUG_EX(	3,318,940✔
40	path.size() < suffix_len \|\| path.substr(path.size() - suffix_len, suffix_len) != c_fresh_suffix, path);	3,318,940✔
41	return path + c_fresh_suffix.data();	3,318,940✔
42	}	3,318,940✔
43
44	bool is_fresh_path(const std::string& path)
45	{	3,400✔
46	const size_t suffix_len = c_fresh_suffix.size();	3,400✔
47	REALM_ASSERT(path.length());	3,400✔
48	if (path.size() < suffix_len) {	3,400✔
49	return false;	×
50	}	×
51	return path.substr(path.size() - suffix_len, suffix_len) == c_fresh_suffix;	3,400✔
52	}	3,400✔
53
54	bool perform_client_reset(util::Logger& logger, DB& db, DB& fresh_db, ClientResyncMode mode,
55	CallbackBeforeType notify_before, CallbackAfterType notify_after,
56	sync::SaltedFileIdent new_file_ident, sync::SubscriptionStore* sub_store,
57	util::FunctionRef<void(int64_t)> on_flx_version, bool recovery_is_allowed)
58	{	404✔
59	REALM_ASSERT(mode != ClientResyncMode::Manual);	404✔
60	logger.debug("Possibly beginning client reset operation: realm_path = %1, mode = %2, recovery_allowed = %3",	404✔
61	db.get_path(), mode, recovery_is_allowed);	404✔
62		202✔
63	auto always_try_clean_up = util::make_scope_exit([&]() noexcept {	404✔
64	std::string path_to_clean = fresh_db.get_path();	404✔
65	try {	404✔
66	fresh_db.close();	404✔
67	constexpr bool delete_lockfile = true;	404✔
68	DB::delete_files(path_to_clean, nullptr, delete_lockfile);	404✔
69	}	404✔
70	catch (const std::exception& err) {	202✔
UNCOV 71	logger.warn("In ClientResetOperation::finalize, the fresh copy '%1' could not be cleaned up due to "	×
UNCOV 72	"an exception: '%2'",	×
UNCOV 73	path_to_clean, err.what());	×
74	// ignored, this is just a best effort
UNCOV 75	}	×
76	});	404✔
77		202✔
78	// only do the reset if there is data to reset	202✔
79	// if there is nothing in this Realm, then there is nothing to reset and	202✔
80	// sync should be able to continue as normal	202✔
81	auto latest_version = db.get_version_id_of_latest_snapshot();	404✔
82	bool local_realm_exists = latest_version.version > 1;	404✔
83	if (!local_realm_exists) {	404✔
84	logger.debug("Local Realm file has never been written to, so skipping client reset.");	4✔
85	return false;	4✔
86	}	4✔
87		200✔
88	VersionID frozen_before_state_version = notify_before ? notify_before() : latest_version;	400✔
89		200✔
90	// If m_notify_after is set, pin the previous state to keep it around.	200✔
91	TransactionRef previous_state;	400✔
92	if (notify_after) {	400✔
93	previous_state = db.start_frozen(frozen_before_state_version);	248✔
94	}	248✔
95	bool did_recover_out = false;	400✔
96	client_reset::perform_client_reset_diff(db, fresh_db, new_file_ident, logger, mode, recovery_is_allowed,	400✔
97	&did_recover_out, sub_store,	400✔
98	on_flx_version); // throws	400✔
99		200✔
100	if (notify_after) {	400✔
101	notify_after(previous_state->get_version_of_current_transaction(), did_recover_out);	188✔
102	}	188✔
103		200✔
104	return true;	400✔
105	}	400✔
106
107	} // namespace realm::_impl::client_reset

realm / realm-core / github_pull_request_285284

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous