Skip to content
Navigation Menu
{{ message }}
forked from apache/cassandra-cpp-driver
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathexecution_profile.cpp
More file actions
210 lines (183 loc) · 9.1 KB
/
Copy pathexecution_profile.cpp
File metadata and controls
210 lines (183 loc) · 9.1 KB
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
/*
Copyright (c) DataStax, Inc.
This software can be used solely with DataStax Enterprise. Please consult the
license at http://www.datastax.com/terms/datastax-dse-driver-license-terms
*/
#include "execution_profile.hpp"
#include "memory.hpp"
extern "C" {
CassExecProfile* cass_execution_profile_new() {
cass::ExecutionProfile* profile =
cass::Memory::allocate<cass::ExecutionProfile>();
return CassExecProfile::to(profile);
}
void cass_execution_profile_free(CassExecProfile* profile) {
cass::Memory::deallocate(profile->from());
}
CassError cass_execution_profile_set_request_timeout(CassExecProfile* profile,
cass_uint64_t timeout_ms) {
profile->set_request_timeout(timeout_ms);
return CASS_OK;
}
CassError cass_execution_profile_set_consistency(CassExecProfile* profile,
CassConsistency consistency) {
profile->set_consistency(consistency);
return CASS_OK;
}
CassError cass_execution_profile_set_serial_consistency(CassExecProfile* profile,
CassConsistency serial_consistency) {
profile->set_serial_consistency(serial_consistency);
return CASS_OK;
}
CassError cass_execution_profile_set_load_balance_round_robin(CassExecProfile* profile) {
profile->set_load_balancing_policy(
cass::Memory::allocate<cass::RoundRobinPolicy>());
return CASS_OK;
}
CassError cass_execution_profile_set_load_balance_dc_aware(CassExecProfile* profile,
const char* local_dc,
unsigned used_hosts_per_remote_dc,
cass_bool_t allow_remote_dcs_for_local_cl) {
if (local_dc == NULL) {
return CASS_ERROR_LIB_BAD_PARAMS;
}
return cass_execution_profile_set_load_balance_dc_aware_n(profile,
local_dc,
SAFE_STRLEN(local_dc),
used_hosts_per_remote_dc,
allow_remote_dcs_for_local_cl);
}
CassError cass_execution_profile_set_load_balance_dc_aware_n(CassExecProfile* profile,
const char* local_dc,
size_t local_dc_length,
unsigned used_hosts_per_remote_dc,
cass_bool_t allow_remote_dcs_for_local_cl) {
if (local_dc == NULL || local_dc_length == 0) {
return CASS_ERROR_LIB_BAD_PARAMS;
}
profile->set_load_balancing_policy(
cass::Memory::allocate<cass::DCAwarePolicy>(cass::String(local_dc, local_dc_length),
used_hosts_per_remote_dc,
!allow_remote_dcs_for_local_cl));
return CASS_OK;
}
CassError cass_execution_profile_set_token_aware_routing(CassExecProfile* profile,
cass_bool_t enabled) {
profile->set_token_aware_routing(enabled == cass_true);
return CASS_OK;
}
CassError cass_execution_profile_set_token_aware_routing_shuffle_replicas(CassExecProfile* profile,
cass_bool_t enabled) {
profile->set_token_aware_routing_shuffle_replicas(enabled == cass_true);
return CASS_OK;
}
CassError cass_execution_profile_set_latency_aware_routing(CassExecProfile* profile,
cass_bool_t enabled) {
profile->set_latency_aware_routing(enabled == cass_true);
return CASS_OK;
}
CassError cass_execution_profile_set_latency_aware_routing_settings(CassExecProfile* profile,
cass_double_t exclusion_threshold,
cass_uint64_t scale_ms,
cass_uint64_t retry_period_ms,
cass_uint64_t update_rate_ms,
cass_uint64_t min_measured) {
cass::LatencyAwarePolicy::Settings settings;
settings.exclusion_threshold = exclusion_threshold;
settings.scale_ns = scale_ms * 1000 * 1000;
settings.retry_period_ns = retry_period_ms * 1000 * 1000;
settings.update_rate_ms = update_rate_ms;
settings.min_measured = min_measured;
profile->set_latency_aware_routing_settings(settings);
return CASS_OK;
}
CassError cass_execution_profile_set_whitelist_filtering(CassExecProfile* profile,
const char* hosts) {
return cass_execution_profile_set_whitelist_filtering_n(profile,
hosts,
SAFE_STRLEN(hosts));
return CASS_OK;
}
CassError cass_execution_profile_set_whitelist_filtering_n(CassExecProfile* profile,
const char* hosts,
size_t hosts_length) {
if (hosts_length == 0) {
profile->whitelist().clear();
} else {
cass::explode(cass::String(hosts, hosts_length),
profile->whitelist());
}
return CASS_OK;
}
CassError cass_execution_profile_set_blacklist_filtering(CassExecProfile* profile,
const char* hosts) {
return cass_execution_profile_set_blacklist_filtering_n(profile,
hosts,
SAFE_STRLEN(hosts));
}
CassError cass_execution_profile_set_blacklist_filtering_n(CassExecProfile* profile,
const char* hosts,
size_t hosts_length) {
if (hosts_length == 0) {
profile->blacklist().clear();
} else {
cass::explode(cass::String(hosts, hosts_length),
profile->blacklist());
}
return CASS_OK;
}
CassError cass_execution_profile_set_whitelist_dc_filtering(CassExecProfile* profile,
const char* dcs) {
return cass_execution_profile_set_whitelist_dc_filtering_n(profile,
dcs,
SAFE_STRLEN(dcs));
}
CassError cass_execution_profile_set_whitelist_dc_filtering_n(CassExecProfile* profile,
const char* dcs,
size_t dcs_length) {
if (dcs_length == 0) {
profile->whitelist_dc().clear();
} else {
cass::explode(cass::String(dcs, dcs_length),
profile->whitelist_dc());
}
return CASS_OK;
}
CassError cass_execution_profile_set_blacklist_dc_filtering(CassExecProfile* profile,
const char* dcs) {
return cass_execution_profile_set_blacklist_dc_filtering_n(profile,
dcs,
SAFE_STRLEN(dcs));
}
CassError cass_execution_profile_set_blacklist_dc_filtering_n(CassExecProfile* profile,
const char* dcs,
size_t dcs_length) {
if (dcs_length == 0) {
profile->blacklist_dc().clear();
} else {
cass::explode(cass::String(dcs, dcs_length),
profile->blacklist_dc());
}
return CASS_OK;
}
CassError cass_execution_profile_set_retry_policy(CassExecProfile* profile,
CassRetryPolicy* retry_policy) {
profile->set_retry_policy(retry_policy);
return CASS_OK;
}
CassError cass_execution_profile_set_constant_speculative_execution_policy(CassExecProfile* profile,
cass_int64_t constant_delay_ms,
int max_speculative_executions) {
if (constant_delay_ms < 0 || max_speculative_executions < 0) {
return CASS_ERROR_LIB_BAD_PARAMS;
}
profile->set_speculative_execution_policy(
cass::Memory::allocate<cass::ConstantSpeculativeExecutionPolicy>(constant_delay_ms,
max_speculative_executions));
return CASS_OK;
}
CassError cass_execution_profile_set_no_speculative_execution_policy(CassExecProfile* profile) {
profile->set_speculative_execution_policy(cass::Memory::allocate<cass::NoSpeculativeExecutionPolicy>());
return CASS_OK;
}
} // extern "C"
You can’t perform that action at this time.