1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/document/bucket/fixed_bucket_spaces.h>
#include "cluster_state_bundle.h"
#include "clusterstate.h"
#include <iostream>
#include <sstream>
namespace storage::lib {
ClusterStateBundle::FeedBlock::FeedBlock(bool block_feed_in_cluster_in,
const vespalib::string& description_in)
: _block_feed_in_cluster(block_feed_in_cluster_in),
_description(description_in)
{
}
bool
ClusterStateBundle::FeedBlock::operator==(const FeedBlock& rhs) const
{
return (_block_feed_in_cluster == rhs._block_feed_in_cluster) &&
(_description == rhs._description);
}
ClusterStateBundle::ClusterStateBundle(const ClusterState &baselineClusterState)
: _baselineClusterState(std::make_shared<const ClusterState>(baselineClusterState)),
_derivedBucketSpaceStates(),
_feed_block(),
_deferredActivation(false)
{
}
ClusterStateBundle::ClusterStateBundle(const ClusterState& baselineClusterState,
BucketSpaceStateMapping derivedBucketSpaceStates)
: _baselineClusterState(std::make_shared<const ClusterState>(baselineClusterState)),
_derivedBucketSpaceStates(std::move(derivedBucketSpaceStates)),
_feed_block(),
_deferredActivation(false)
{
}
ClusterStateBundle::ClusterStateBundle(const ClusterState& baselineClusterState,
BucketSpaceStateMapping derivedBucketSpaceStates,
bool deferredActivation)
: _baselineClusterState(std::make_shared<const ClusterState>(baselineClusterState)),
_derivedBucketSpaceStates(std::move(derivedBucketSpaceStates)),
_feed_block(),
_deferredActivation(deferredActivation)
{
}
ClusterStateBundle::ClusterStateBundle(const ClusterState& baselineClusterState,
BucketSpaceStateMapping derivedBucketSpaceStates,
const FeedBlock& feed_block_in,
bool deferredActivation)
: _baselineClusterState(std::make_shared<const ClusterState>(baselineClusterState)),
_derivedBucketSpaceStates(std::move(derivedBucketSpaceStates)),
_feed_block(feed_block_in),
_deferredActivation(deferredActivation)
{
}
ClusterStateBundle::ClusterStateBundle(const ClusterStateBundle&) = default;
ClusterStateBundle& ClusterStateBundle::operator=(const ClusterStateBundle&) = default;
ClusterStateBundle::ClusterStateBundle(ClusterStateBundle&&) noexcept = default;
ClusterStateBundle& ClusterStateBundle::operator=(ClusterStateBundle&&) noexcept = default;
ClusterStateBundle::~ClusterStateBundle() = default;
const std::shared_ptr<const lib::ClusterState> &
ClusterStateBundle::getBaselineClusterState() const
{
return _baselineClusterState;
}
const std::shared_ptr<const lib::ClusterState> &
ClusterStateBundle::getDerivedClusterState(document::BucketSpace bucketSpace) const
{
auto itr = _derivedBucketSpaceStates.find(bucketSpace);
if (itr != _derivedBucketSpaceStates.end()) {
return itr->second;
}
return _baselineClusterState;
}
uint32_t
ClusterStateBundle::getVersion() const
{
return _baselineClusterState->getVersion();
}
bool
ClusterStateBundle::operator==(const ClusterStateBundle &rhs) const noexcept
{
if (!(*_baselineClusterState == *rhs._baselineClusterState)) {
return false;
}
if (_derivedBucketSpaceStates.size() != rhs._derivedBucketSpaceStates.size()) {
return false;
}
if (_feed_block != rhs._feed_block) {
return false;
}
if (_deferredActivation != rhs._deferredActivation) {
return false;
}
// Can't do a regular operator== comparison since we must check equality
// of cluster state _values_, not their _pointers_.
for (auto& lhs_ds : _derivedBucketSpaceStates) {
auto rhs_iter = rhs._derivedBucketSpaceStates.find(lhs_ds.first);
if ((rhs_iter == rhs._derivedBucketSpaceStates.end())
|| !(*lhs_ds.second == *rhs_iter->second)) {
return false;
}
}
return true;
}
std::string
ClusterStateBundle::toString() const
{
std::ostringstream os;
os << *this;
return os.str();
}
std::ostream& operator<<(std::ostream& os, const ClusterStateBundle& bundle) {
os << "ClusterStateBundle('" << *bundle.getBaselineClusterState();
if (!bundle.getDerivedClusterStates().empty()) {
// Output ordering is undefined for of per-space states.
for (auto& ds : bundle.getDerivedClusterStates()) {
os << "', ";
os << document::FixedBucketSpaces::to_string(ds.first);
os << " '" << *ds.second;
}
}
os << '\'';
if (bundle.block_feed_in_cluster()) {
os << ", feed blocked: '" << bundle.feed_block()->description() << "'";
}
if (bundle.deferredActivation()) {
os << " (deferred activation)";
}
os << ")";
return os;
}
}
|
