mirror of
https://github.com/scylladb/scylladb.git
synced 2026-04-22 17:40:34 +00:00
5e8c9a369e
"When there are at least 2 nodes upgraded to 2.0, and the two exchanged schema
for some reason, reads or writes which involve both 1.7 and 2.0 nodes may
start to fail with the following error logged:
storage_proxy - Exception when communicating with 127.0.0.3: Failed to load schema version 58fc9b89-74ab-37ca-8640-8b38a1204f8d
The situation should heal after whole cluster is upgraded.
Table schema versions are calculated by 2.0 nodes differently than 1.7 nodes
due to change in the schema tables format. Mismatch is meant to be avoided by
having 2.0 nodes calculate the old digest on schema migration during upgrade,
and use that version until next time the table is altered. It is thus not
allowed to alter tables during the rolling upgrade.
Two 2.0 nodes may exchange schema, if they detect through gossip that their
schema versions don't match. They may not match temporarily during boot, until
the upgraded node completes the bootstrap and propagates its new schema
through gossip. One source of such temporary mismatch is construction of new
tracing tables, which didn't exist on 1.7. Such schema pull will result in a
schema merge, which cause all tables to be altered and their schema version to
be recalculated. The new schema will not match the one used by 1.7 nodes,
causing reads and writes to fail, because schema requesting won't work during
rolling upgrade from 1.7 to 2.0.
The main fix employed here is to hold schema pulls, even among 2.0 nodes,
until rolling upgrade is complete."
Fixes #2802.
* 'tgrabiec/fix-schema-mismatch' of github.com:scylladb/seastar-dev:
tests: schema_change_test: Add test_merging_does_not_alter_tables_which_didnt_change test case
tests: cql_test_env: Enable all features in tests
schema_tables: Make make_scylla_tables_mutation() visible
migration_manager: Disable pulls during rolling upgrade from 1.7
storage_service: Introduce SCHEMA_TABLES_V3 feature
schema_tables: Don't alter tables which differ only in version
schema_mutations: Use mutation_opt instead of stdx::optional<mutation>
(cherry picked from commit 8378fe190a)
114 lines
4.1 KiB
C++
114 lines
4.1 KiB
C++
/*
|
|
* Copyright 2015 ScyllaDB
|
|
*/
|
|
|
|
/*
|
|
* This file is part of Scylla.
|
|
*
|
|
* Scylla is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Scylla 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
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "schema_mutations.hh"
|
|
#include "canonical_mutation.hh"
|
|
#include "db/schema_tables.hh"
|
|
#include "md5_hasher.hh"
|
|
|
|
schema_mutations::schema_mutations(canonical_mutation columnfamilies,
|
|
canonical_mutation columns,
|
|
bool is_view,
|
|
stdx::optional<canonical_mutation> indices,
|
|
stdx::optional<canonical_mutation> dropped_columns,
|
|
stdx::optional<canonical_mutation> scylla_tables)
|
|
: _columnfamilies(columnfamilies.to_mutation(is_view ? db::schema_tables::views() : db::schema_tables::tables()))
|
|
, _columns(columns.to_mutation(db::schema_tables::columns()))
|
|
, _indices(indices ? mutation_opt{indices.value().to_mutation(db::schema_tables::indexes())} : stdx::nullopt)
|
|
, _dropped_columns(dropped_columns ? mutation_opt{dropped_columns.value().to_mutation(db::schema_tables::dropped_columns())} : stdx::nullopt)
|
|
, _scylla_tables(scylla_tables ? mutation_opt{scylla_tables.value().to_mutation(db::schema_tables::scylla_tables())} : stdx::nullopt)
|
|
{}
|
|
|
|
void schema_mutations::copy_to(std::vector<mutation>& dst) const {
|
|
dst.push_back(_columnfamilies);
|
|
dst.push_back(_columns);
|
|
if (_indices) {
|
|
dst.push_back(*_indices);
|
|
}
|
|
if (_dropped_columns) {
|
|
dst.push_back(*_dropped_columns);
|
|
}
|
|
if (_scylla_tables) {
|
|
dst.push_back(*_scylla_tables);
|
|
}
|
|
}
|
|
|
|
table_schema_version schema_mutations::digest() const {
|
|
if (_scylla_tables) {
|
|
auto rs = query::result_set(*_scylla_tables);
|
|
if (!rs.empty()) {
|
|
auto&& row = rs.row(0);
|
|
if (row.has("version")) {
|
|
auto val = row.get<utils::UUID>("version");
|
|
if (val) {
|
|
return *val;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
md5_hasher h;
|
|
db::schema_tables::feed_hash_for_schema_digest(h, _columnfamilies);
|
|
db::schema_tables::feed_hash_for_schema_digest(h, _columns);
|
|
if (_indices && !_indices->partition().empty()) {
|
|
db::schema_tables::feed_hash_for_schema_digest(h, *_indices);
|
|
}
|
|
if (_dropped_columns && !_dropped_columns->partition().empty()) {
|
|
db::schema_tables::feed_hash_for_schema_digest(h, *_dropped_columns);
|
|
}
|
|
if (_scylla_tables) {
|
|
db::schema_tables::feed_hash_for_schema_digest(h, *_scylla_tables);
|
|
}
|
|
return utils::UUID_gen::get_name_UUID(h.finalize());
|
|
}
|
|
|
|
static mutation_opt compact(const mutation_opt& m) {
|
|
if (!m) {
|
|
return m;
|
|
}
|
|
return db::schema_tables::compact_for_schema_digest(*m);
|
|
}
|
|
|
|
static mutation_opt compact(const mutation& m) {
|
|
return db::schema_tables::compact_for_schema_digest(m);
|
|
}
|
|
|
|
bool schema_mutations::operator==(const schema_mutations& other) const {
|
|
return compact(_columnfamilies) == compact(other._columnfamilies)
|
|
&& compact(_columns) == compact(other._columns)
|
|
&& compact(_indices) == compact(other._indices)
|
|
&& compact(_dropped_columns) == compact(other._dropped_columns)
|
|
&& compact(_scylla_tables) == compact(other._scylla_tables)
|
|
;
|
|
}
|
|
|
|
bool schema_mutations::operator!=(const schema_mutations& other) const {
|
|
return !(*this == other);
|
|
}
|
|
|
|
bool schema_mutations::live() const {
|
|
return _columnfamilies.live_row_count() > 0 || _columns.live_row_count() > 0;
|
|
}
|
|
|
|
bool schema_mutations::is_view() const {
|
|
return _columnfamilies.schema() == db::schema_tables::views();
|
|
}
|