bahman/scylla
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

abstract_replication_strategy: calculate_natural_endpoints: return endpoint_set

Browse Source 
So it could be used also for easily searching for an endpoint.

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>
This commit is contained in:
Benny Halevy
2022-07-12 14:29:26 +03:00
parent 38934413d4
commit 7017ad6822
13 changed files with 101 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
locator/abstract_replication_strategy.cc
View File

@@ -286,7 +286,7 @@ abstract_replication_strategy::get_range_addresses(const token_metadata& tm) con
dht::token_range_vector ranges = tm.get_primary_ranges_for(t);
auto eps = co_await calculate_natural_endpoints(t, tm);
for (auto& r : ranges) {
ret.emplace(r, eps);
ret.emplace(r, eps.get_vector());
}
}
co_return ret;
@@ -314,7 +314,8 @@ future<mutable_effective_replication_map_ptr> calculate_effective_replication_ma
replication_map replication_map;
for (const auto &t : tmptr->sorted_tokens()) {
replication_map.emplace(t, co_await rs->calculate_natural_endpoints(t, *tmptr));
auto eps = co_await rs->calculate_natural_endpoints(t, *tmptr);
replication_map.emplace(t, eps.get_vector());
}
auto rf = rs->get_replication_factor(*tmptr);

5
locator/abstract_replication_strategy.hh
View File

@@ -18,6 +18,7 @@
#include "snitch_base.hh"
#include <seastar/util/bool_class.hh>
#include "utils/maybe_yield.hh"
#include "utils/sequenced_set.hh"
// forward declaration since replica/database.hh includes this file
namespace replica {
@@ -44,6 +45,8 @@ using replication_strategy_config_options = std::map<sstring, sstring>;
using replication_map = std::unordered_map<token, inet_address_vector_replica_set>;
using endpoint_set = utils::basic_sequenced_set<inet_address, inet_address_vector_replica_set>;
class effective_replication_map;
class effective_replication_map_factory;
@@ -80,7 +83,7 @@ public:
// is small, that implementation may not yield since by itself it won't cause a reactor stall (assuming practical
// cluster sizes and number of tokens per node). The caller is responsible for yielding if they call this function
// in a loop.
virtual future<inet_address_vector_replica_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const = 0;
virtual future<endpoint_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const = 0;
virtual ~abstract_replication_strategy() {}
static ptr_type create_replication_strategy(const sstring& strategy_name, const replication_strategy_config_options& config_options);

5
locator/everywhere_replication_strategy.cc
View File

@@ -19,8 +19,9 @@ namespace locator {
everywhere_replication_strategy::everywhere_replication_strategy(const replication_strategy_config_options& config_options) :
abstract_replication_strategy(config_options, replication_strategy_type::everywhere_topology) {}
future<inet_address_vector_replica_set> everywhere_replication_strategy::calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const {
return make_ready_future<inet_address_vector_replica_set>(boost::copy_range<inet_address_vector_replica_set>(tm.get_all_endpoints()));
future<endpoint_set> everywhere_replication_strategy::calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const {
auto eps = tm.get_all_endpoints();
return make_ready_future<endpoint_set>(endpoint_set(eps.begin(), eps.end()));
}
size_t everywhere_replication_strategy::get_replication_factor(const token_metadata& tm) const {

2
locator/everywhere_replication_strategy.hh
View File

@@ -18,7 +18,7 @@ class everywhere_replication_strategy : public abstract_replication_strategy {
public:
everywhere_replication_strategy(const replication_strategy_config_options& config_options);
virtual future<inet_address_vector_replica_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
virtual future<endpoint_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
virtual void validate_options() const override { /* noop */ }

4
locator/local_strategy.cc
View File

@@ -17,8 +17,8 @@ namespace locator {
local_strategy::local_strategy(const replication_strategy_config_options& config_options) :
abstract_replication_strategy(config_options, replication_strategy_type::local) {}
future<inet_address_vector_replica_set> local_strategy::calculate_natural_endpoints(const token& t, const token_metadata& tm) const {
return make_ready_future<inet_address_vector_replica_set>(inet_address_vector_replica_set({utils::fb_utilities::get_broadcast_address()}));
future<endpoint_set> local_strategy::calculate_natural_endpoints(const token& t, const token_metadata& tm) const {
return make_ready_future<endpoint_set>(endpoint_set({utils::fb_utilities::get_broadcast_address()}));
}
void local_strategy::validate_options() const {

2
locator/local_strategy.hh
View File

@@ -27,7 +27,7 @@ public:
virtual ~local_strategy() {};
virtual size_t get_replication_factor(const token_metadata&) const override;
virtual future<inet_address_vector_replica_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
virtual future<endpoint_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
virtual void validate_options() const override;

8
locator/network_topology_strategy.cc
View File

@@ -14,7 +14,6 @@
#include <seastar/coroutine/maybe_yield.hh>
#include "locator/network_topology_strategy.hh"
#include "utils/sequenced_set.hh"
#include <boost/algorithm/string.hpp>
#include "utils/hash.hh"
@@ -75,7 +74,6 @@ network_topology_strategy::network_topology_strategy(
}
}
using endpoint_set = utils::sequenced_set<inet_address>;
using endpoint_dc_rack_set = std::unordered_set<endpoint_dc_rack>;
class natural_endpoints_tracker {
@@ -234,12 +232,12 @@ public:
return _dcs_to_fill == 0;
}
const endpoint_set& replicas() const noexcept {
endpoint_set& replicas() noexcept {
return _replicas;
}
};
future<inet_address_vector_replica_set>
future<endpoint_set>
network_topology_strategy::calculate_natural_endpoints(
const token& search_token, const token_metadata& tm) const {
@@ -254,7 +252,7 @@ network_topology_strategy::calculate_natural_endpoints(
}
}
co_return boost::copy_range<inet_address_vector_replica_set>(tracker.replicas().get_vector());
co_return std::move(tracker.replicas());
}
void network_topology_strategy::validate_options() const {

2
locator/network_topology_strategy.hh
View File

@@ -44,7 +44,7 @@ protected:
* calculate endpoints in one pass through the tokens by tracking our
* progress in each DC, rack etc.
*/
virtual future<inet_address_vector_replica_set> calculate_natural_endpoints(
virtual future<endpoint_set> calculate_natural_endpoints(
const token& search_token, const token_metadata& tm) const override;
virtual void validate_options() const override;

8
locator/simple_strategy.cc
View File

@@ -33,15 +33,15 @@ simple_strategy::simple_strategy(const replication_strategy_config_options& conf
}
}
future<inet_address_vector_replica_set> simple_strategy::calculate_natural_endpoints(const token& t, const token_metadata& tm) const {
future<endpoint_set> simple_strategy::calculate_natural_endpoints(const token& t, const token_metadata& tm) const {
const std::vector<token>& tokens = tm.sorted_tokens();
if (tokens.empty()) {
co_return inet_address_vector_replica_set();
co_return endpoint_set();
}
size_t replicas = _replication_factor;
utils::sequenced_set<inet_address> endpoints;
endpoint_set endpoints;
endpoints.reserve(replicas);
for (auto& token : tm.ring_range(t)) {
@@ -60,7 +60,7 @@ future<inet_address_vector_replica_set> simple_strategy::calculate_natural_endpo
co_await coroutine::maybe_yield();
}
co_return boost::copy_range<inet_address_vector_replica_set>(endpoints.get_vector());
co_return endpoints;
}
size_t simple_strategy::get_replication_factor(const token_metadata&) const {

2
locator/simple_strategy.hh
View File

@@ -26,7 +26,7 @@ public:
return true;
}
virtual future<inet_address_vector_replica_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
virtual future<endpoint_set> calculate_natural_endpoints(const token& search_token, const token_metadata& tm) const override;
private:
size_t _replication_factor = 1;
};