Value::Value(int protocol_version,
const SharedRefPtr<const DataType>& data_type,
char* data, int32_t size)
: protocol_version_(protocol_version)
, data_type_(data_type) {
if (size > 0 && data_type->is_collection()) {
data_ = decode_size(protocol_version, data, count_);
if (protocol_version_ >= 3) {
size_ = size - sizeof(int32_t);
} else {
size_ = size - sizeof(uint16_t);
}
} else {
if (data_type->is_tuple()) {
SharedRefPtr<const SubTypesDataType> sub_types(data_type);
count_ = sub_types->types().size();
} else if (data_type->is_user_type()) {
SharedRefPtr<const UserType> user_type(data_type);
count_ = user_type->fields().size();
} else {
count_ = 0;
}
data_ = data;
size_ = size;
}
}
SharedRefPtr<Host> LatencyAwarePolicy::LatencyAwareQueryPlan::compute_next() {
int64_t min = policy_->min_average_.load();
const Settings& settings = policy_->settings_;
uint64_t now = uv_hrtime();
SharedRefPtr<Host> host;
while ((host = child_plan_->compute_next())) {
TimestampedAverage latency = host->get_current_average();
if (min < 0 ||
latency.average < 0 ||
latency.num_measured < settings.min_measured ||
(now - latency.timestamp) > settings.retry_period_ns) {
return host;
}
if (latency.average <= static_cast<int64_t>(settings.exclusion_threshold * min)) {
return host;
}
skipped_.push_back(host);
}
if (skipped_index_ < skipped_.size()) {
return skipped_[skipped_index_++];
}
return SharedRefPtr<Host>();
}
void DCAwarePolicy::on_remove(const SharedRefPtr<Host>& host) {
const std::string& dc = host->dc();
if (dc == local_dc_) {
remove_host(local_dc_live_hosts_, host);
} else {
per_remote_dc_live_hosts_.remove_host_from_dc(host->dc(), host);
}
}
void Session::on_remove(SharedRefPtr<Host> host) {
load_balancing_policy_->on_remove(host);
{ // Lock hosts
ScopedMutex l(&hosts_mutex_);
hosts_.erase(host->address());
}
for (IOWorkerVec::iterator it = io_workers_.begin(),
end = io_workers_.end(); it != end; ++it) {
(*it)->remove_pool_async(host->address(), true);
}
}
void DCAwarePolicy::init(const SharedRefPtr<Host>& connected_host, const HostMap& hosts) {
if (local_dc_.empty() && !connected_host->dc().empty()) {
LOG_INFO("Using '%s' for the local data center "
"(if this is incorrect, please provide the correct data center)",
connected_host->dc().c_str());
local_dc_ = connected_host->dc();
}
for (HostMap::const_iterator i = hosts.begin(),
end = hosts.end(); i != end; ++i) {
on_add(i->second);
}
}
void Session::on_up(SharedRefPtr<Host> host) {
host->set_up();
if (load_balancing_policy_->distance(host) == CASS_HOST_DISTANCE_IGNORE) {
return;
}
load_balancing_policy_->on_up(host);
for (IOWorkerVec::iterator it = io_workers_.begin(),
end = io_workers_.end(); it != end; ++it) {
(*it)->add_pool_async(host->address(), false);
}
}
void DCAwarePolicy::on_add(const SharedRefPtr<Host>& host) {
const std::string& dc = host->dc();
if (local_dc_.empty() && !dc.empty()) {
LOG_INFO("Using '%s' for local data center "
"(if this is incorrect, please provide the correct data center)",
host->dc().c_str());
local_dc_ = dc;
}
if (dc == local_dc_) {
local_dc_live_hosts_->push_back(host);
} else {
per_remote_dc_live_hosts_.add_host_to_dc(dc, host);
}
}
CassHostDistance DCAwarePolicy::distance(const SharedRefPtr<Host>& host) const {
if (local_dc_.empty() || host->dc() == local_dc_) {
return CASS_HOST_DISTANCE_LOCAL;
}
const CopyOnWriteHostVec& hosts = per_remote_dc_live_hosts_.get_hosts(host->dc());
size_t num_hosts = std::min(hosts->size(), used_hosts_per_remote_dc_);
for (size_t i = 0; i < num_hosts; ++i) {
if ((*hosts)[i]->address() == host->address()) {
return CASS_HOST_DISTANCE_REMOTE;
}
}
return CASS_HOST_DISTANCE_IGNORE;
}
void Session::on_down(SharedRefPtr<Host> host) {
host->set_down();
load_balancing_policy_->on_down(host);
bool cancel_reconnect = false;
if (load_balancing_policy_->distance(host) == CASS_HOST_DISTANCE_IGNORE) {
// This permanently removes a host from all IO workers by stopping
// any attempt to reconnect to that host.
cancel_reconnect = true;
}
for (IOWorkerVec::iterator it = io_workers_.begin(),
end = io_workers_.end(); it != end; ++it) {
(*it)->remove_pool_async(host->address(), cancel_reconnect);
}
}
void Session::on_add(SharedRefPtr<Host> host, bool is_initial_connection) {
host->set_up();
if (load_balancing_policy_->distance(host) == CASS_HOST_DISTANCE_IGNORE) {
return;
}
if (is_initial_connection) {
pending_pool_count_ += io_workers_.size();
} else {
load_balancing_policy_->on_add(host);
}
for (IOWorkerVec::iterator it = io_workers_.begin(),
end = io_workers_.end(); it != end; ++it) {
(*it)->add_pool_async(host->address(), is_initial_connection);
}
}
SharedRefPtr<Host> TokenAwarePolicy::TokenAwareQueryPlan::compute_next() {
while (remaining_ > 0) {
--remaining_;
const SharedRefPtr<Host>& host((*replicas_)[index_++ % replicas_->size()]);
if (host->is_up() && child_policy_->distance(host) == CASS_HOST_DISTANCE_LOCAL) {
return host;
}
}
SharedRefPtr<Host> host;
while ((host = child_plan_->compute_next())) {
if (!contains(replicas_, host->address()) ||
child_policy_->distance(host) != CASS_HOST_DISTANCE_LOCAL) {
return host;
}
}
return SharedRefPtr<Host>();
}
bool BlacklistDCPolicy::is_valid_host(const SharedRefPtr<Host>& host) const {
const std::string& host_dc = host->dc();
for (DcList::const_iterator it = dcs_.begin(),
end = dcs_.end(); it != end; ++it) {
if (host_dc.compare(*it) == 0) {
return false;
}
}
return true;
}
bool BlacklistPolicy::is_valid_host(const SharedRefPtr<Host>& host) const {
const std::string& host_address = host->address().to_string(false);
for (ContactPointList::const_iterator it = hosts_.begin(),
end = hosts_.end();
it != end; ++it) {
if (host_address.compare(*it) == 0) {
return false;
}
}
return true;
}
void HostTargetingPolicy::on_down(const SharedRefPtr<Host>& host) {
available_hosts_.erase(host->address());
ChainedLoadBalancingPolicy::on_down(host);
}
void HostTargetingPolicy::on_up(const SharedRefPtr<Host>& host) {
available_hosts_[host->address()] = host;
ChainedLoadBalancingPolicy::on_up(host);
}
UserTypeValue(const SharedRefPtr<const UserType>& data_type)
: AbstractData(data_type->fields().size())
, data_type_(data_type) { }
void LatencyAwarePolicy::on_add(const SharedRefPtr<Host>& host) {
host->enable_latency_tracking(settings_.scale_ns, settings_.min_measured);
add_host(hosts_, host);
ChainedLoadBalancingPolicy::on_add(host);
}