36 #include <boost/archive/binary_iarchive.hpp> 39 #include <boost/filesystem/operations.hpp> 40 #include <boost/range/join.hpp> 41 #include <boost/serialization/version.hpp> 50 constexpr
unsigned CURRENT_PEERLIST_STORAGE_ARCHIVE_VER = 6;
57 bool operator()(
const T& left,
const zone right)
const 59 return left.adr.get_zone() < right;
63 bool operator()(
const zone left,
const T& right)
const 65 return left < right.adr.get_zone();
68 template<
typename T,
typename U>
69 bool operator()(
const T& left,
const U& right)
const 71 return left.adr.get_zone() < right.adr.get_zone();
75 template<
typename Elem,
typename Archive>
76 std::vector<Elem> load_peers(Archive&
a,
unsigned ver)
87 std::vector<Elem> elems{};
98 template<
typename Archive,
typename Range>
99 void save_peers(Archive&
a,
const Range& elems)
103 for (
const auto& elem : elems)
110 const auto start = std::lower_bound(src.begin(), src.end(),
zone, by_zone{});
111 const auto end = std::upper_bound(start, src.end(),
zone, by_zone{});
113 std::vector<T>
out{};
114 out.assign(std::make_move_iterator(start), std::make_move_iterator(end));
115 src.erase(start, end);
119 template<
typename Container,
typename T>
120 void add_peers(Container&
dest, std::vector<T>&& src)
122 dest.insert(std::make_move_iterator(src.begin()), std::make_move_iterator(src.end()));
125 template<
typename Container,
typename Range>
126 void copy_peers(Container&
dest,
const Range& src)
138 template<
typename Archive>
141 elem.
white = load_peers<peerlist_entry>(
a, ver);
142 elem.
gray = load_peers<peerlist_entry>(
a, ver);
143 elem.
anchor = load_peers<anchor_peerlist_entry>(
a, ver);
153 template<
typename Archive>
173 boost::archive::binary_iarchive
a{src};
179 std::sort(out.m_types.white.begin(), out.m_types.white.end(), by_zone{});
180 std::sort(out.m_types.gray.begin(), out.m_types.gray.end(), by_zone{});
181 std::sort(out.m_types.anchor.begin(), out.m_types.anchor.end(), by_zone{});
185 catch (
const std::exception& e)
193 std::ifstream src_file{};
194 src_file.open( path , std::ios_base::binary | std::ios_base::in);
198 boost::optional<peerlist_storage> out =
open(src_file,
true);
202 boost::filesystem::copy_file(path, path +
".unportable", boost::filesystem::copy_option::overwrite_if_exists);
204 src_file.open( path , std::ios_base::binary | std::ios_base::in);
208 out =
open(src_file,
false);
214 MWARNING(
"Failed to load p2p config file, falling back to default config");
230 const peerlist_join pj{std::cref(m_types), std::cref(other)};
234 catch (
const boost::archive::archive_exception& e)
242 std::ofstream dest_file{};
243 dest_file.open( path , std::ios_base::binary | std::ios_base::out| std::ios::trunc);
247 return store(dest_file, other);
253 out.white = do_take_zone(m_types.
white,
zone);
254 out.gray = do_take_zone(m_types.
gray,
zone);
255 out.anchor = do_take_zone(m_types.
anchor,
zone);
263 if (!m_peers_white.empty() || !m_peers_gray.empty() || !m_peers_anchor.empty())
266 add_peers(m_peers_white.get<by_addr>(),
std::move(peers.white));
267 add_peers(m_peers_gray.get<by_addr>(),
std::move(peers.gray));
268 add_peers(m_peers_anchor.get<by_addr>(),
std::move(peers.anchor));
269 m_allow_local_ip = allow_local_ip;
276 copy_peers(pl_gray, m_peers_gray.get<by_addr>());
277 copy_peers(pl_white, m_peers_white.get<by_addr>());
283 peers.
white.reserve(peers.
white.size() + m_peers_white.size());
284 peers.
gray.reserve(peers.
gray.size() + m_peers_gray.size());
285 peers.
anchor.reserve(peers.
anchor.size() + m_peers_anchor.size());
287 copy_peers(peers.
white, m_peers_white.get<by_addr>());
288 copy_peers(peers.
gray, m_peers_gray.get<by_addr>());
289 copy_peers(peers.
anchor, m_peers_anchor.get<by_addr>());
CXA_THROW_INFO_T void(* dest)(void *))
void copy(key &AA, const key &A)
unsigned __int64 uint64_t
#define CRITICAL_REGION_LOCAL(x)
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
const T & move(const T &t)
BOOST_CLASS_VERSION(nodetool::peerlist_types, nodetool::CURRENT_PEERLIST_STORAGE_ARCHIVE_VER)