feat(cassandra): configurable consistency and local data centre (#4221)

This commit is contained in:
Hampus authored and GitHub committed 2026-11-16 23:13:09 +01:00
1 parent 5d4953aa2d
commit 3c86dc8514
14 files changed
+337 -8

No files matched your search

+62
View File
@@ -10,11 +10,59 @@ const DEFAULT_READ_TIMEOUT_MS = 5000;
export const BACKGROUND_READ_TIMEOUT_MS = 12000;
export type CassandraConsistencyName = 'one' | 'localOne' | 'quorum' | 'localQuorum' | 'eachQuorum' | 'all';
export type CassandraSerialConsistencyName = 'serial' | 'localSerial';
const CONSISTENCY_NAMES: Record<string, CassandraConsistencyName> = {
one: 'one',
local_one: 'localOne',
quorum: 'quorum',
local_quorum: 'localQuorum',
each_quorum: 'eachQuorum',
all: 'all',
};
const SERIAL_CONSISTENCY_NAMES: Record<string, CassandraSerialConsistencyName> = {
serial: 'serial',
local_serial: 'localSerial',
};
function normalizeConsistencyKey(value: string): string {
return value
.trim()
.replace(/([a-z])([A-Z])/g, '$1_$2')
.toLowerCase();
}
export function parseCassandraConsistency(value: string | undefined): CassandraConsistencyName {
if (!value?.trim()) return 'localQuorum';
const name = CONSISTENCY_NAMES[normalizeConsistencyKey(value)];
if (!name) {
throw new Error(
`Unsupported Cassandra consistency "${value}". Use one of: ${Object.keys(CONSISTENCY_NAMES).join(', ')}`,
);
}
return name;
}
export function parseCassandraSerialConsistency(value: string | undefined): CassandraSerialConsistencyName {
if (!value?.trim()) return 'localSerial';
const name = SERIAL_CONSISTENCY_NAMES[normalizeConsistencyKey(value)];
if (!name) {
throw new Error(
`Unsupported Cassandra serial consistency "${value}". Use one of: ${Object.keys(SERIAL_CONSISTENCY_NAMES).join(', ')}`,
);
}
return name;
}
interface CassandraConfig {
hosts: Array<string>;
port?: number | undefined;
keyspace: string;
localDc: string;
consistency?: CassandraConsistencyName | undefined;
serialConsistency?: CassandraSerialConsistencyName | undefined;
username?: string | undefined;
password?: string | undefined;
readTimeoutMs?: number | undefined;
@@ -44,6 +92,8 @@ class CassandraClient {
port: config.port,
keyspace: config.keyspace,
localDc: config.localDc,
consistency: config.consistency ?? 'localQuorum',
serialConsistency: config.serialConsistency ?? 'localSerial',
username: config.username,
password: config.password,
readTimeoutMs: config.readTimeoutMs,
@@ -65,6 +115,10 @@ class CassandraClient {
contactPoints: this.config.hosts,
keyspace: this.config.keyspace,
localDataCenter: this.config.localDc,
queryOptions: {
consistency: driver.types.consistencies[this.config.consistency ?? 'localQuorum'],
serialConsistency: driver.types.consistencies[this.config.serialConsistency ?? 'localSerial'],
},
protocolOptions: {
port: this.config.port ?? 9042,
},
@@ -100,6 +154,10 @@ class CassandraClient {
await activeClient.shutdown();
}
public getSerialConsistency(): CassandraSerialConsistencyName {
return this.config.serialConsistency ?? 'localSerial';
}
public getNativeClient(): cassandra.Client {
if (this.client === null) {
throw new Error('Cassandra client is not connected. Call connect() first.');
@@ -135,3 +193,7 @@ function getDefaultCassandraClient(): CassandraClient {
export function getClient(): cassandra.Client {
return getDefaultCassandraClient().getNativeClient();
}
export function getSerialConsistency(): CassandraSerialConsistencyName {
return defaultClientState.client?.getSerialConsistency() ?? 'localSerial';
}
+3
View File
@@ -28,6 +28,7 @@ import {smtpTlsModeFromSecure} from '@fluxer/constants/src/SmtpConstants';
import {parseIpAddress} from '@fluxer/ip_utils/src/IpAddress';
import type {GeoEntry} from '@fluxer/schema/src/domains/geolocation/GeolocationSchemas';
import {normalizeString} from '@fluxer/schema/src/primitives/SchemaPrimitives';
import {parseCassandraConsistency, parseCassandraSerialConsistency} from '@pkgs/cassandra/src/Client';
import {parseGeoipSourceConfig, resolveGeoipRuntimeSourceConfig} from '@pkgs/geoip/src/GeoipStartup';
function extractHostname(url: string): string {
@@ -379,6 +380,8 @@ export function buildAPIConfigFromMaster(master: MasterConfig): APIConfig {
port: cassandraSource?.port ?? 9042,
keyspace: cassandraSource?.keyspace ?? '',
localDc: cassandraSource?.local_dc ?? '',
consistency: parseCassandraConsistency(cassandraSource?.consistency),
serialConsistency: parseCassandraSerialConsistency(cassandraSource?.serial_consistency),
username: cassandraSource?.username ?? '',
password: cassandraSource?.password ?? '',
},
+2
View File
@@ -230,6 +230,8 @@ export function createInitializer(
port: config.cassandra.port,
keyspace: config.cassandra.keyspace,
localDc: config.cassandra.localDc,
consistency: config.cassandra.consistency,
serialConsistency: config.cassandra.serialConsistency,
username: config.cassandra.username || undefined,
password: config.cassandra.password || undefined,
}).catch((error: unknown) => {
+3
View File
@@ -11,6 +11,7 @@ import type {AccountIdentityMode, TagStyle} from '@fluxer/constants/src/AccountI
import type {SmtpTlsMode} from '@fluxer/constants/src/SmtpConstants';
import type {GeoEntry} from '@fluxer/schema/src/domains/geolocation/GeolocationSchemas';
import type {OperatorPassCurrency} from '@fluxer/schema/src/domains/operator_pass/OperatorPassSchemas';
import type {CassandraConsistencyName, CassandraSerialConsistencyName} from '@pkgs/cassandra/src/Client';
export type APIWorkerMode = 'all_lanes' | 'single_lane' | 'single_task';
export type APIWorkerLaneName = 'realtime' | 'unfurl' | 'lifecycle' | 'batch' | 'crosspost';
@@ -95,6 +96,8 @@ export interface APIConfig {
port: number;
keyspace: string;
localDc: string;
consistency: CassandraConsistencyName;
serialConsistency: CassandraSerialConsistencyName;
username: string;
password: string;
};
@@ -0,0 +1,26 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
import {parseCassandraConsistency, parseCassandraSerialConsistency} from '@pkgs/cassandra/src/Client';
import {describe, expect, it} from 'vitest';
describe('Cassandra consistency settings', () => {
it('defaults to local levels so requests stay in the local data centre', () => {
expect(parseCassandraConsistency(undefined)).toBe('localQuorum');
expect(parseCassandraConsistency(' ')).toBe('localQuorum');
expect(parseCassandraSerialConsistency(undefined)).toBe('localSerial');
});
it('accepts snake case, upper case and driver names', () => {
expect(parseCassandraConsistency('local_one')).toBe('localOne');
expect(parseCassandraConsistency('EACH_QUORUM')).toBe('eachQuorum');
expect(parseCassandraConsistency('localQuorum')).toBe('localQuorum');
expect(parseCassandraSerialConsistency('SERIAL')).toBe('serial');
expect(parseCassandraSerialConsistency('local_serial')).toBe('localSerial');
});
it('rejects levels that do not exist or do not fit the setting', () => {
expect(() => parseCassandraConsistency('two')).toThrow(/Unsupported Cassandra consistency/);
expect(() => parseCassandraConsistency('serial')).toThrow(/Unsupported Cassandra consistency/);
expect(() => parseCassandraSerialConsistency('quorum')).toThrow(/Unsupported Cassandra serial consistency/);
});
});
@@ -21,7 +21,7 @@ import {LocalDate} from '@app/api/database/LocalDate';
import {Logger} from '@app/api/Logger';
import {chunkArray} from '@app/api/utils/ArrayUtils';
import {ServiceUnavailableError} from '@fluxer/errors/src/domains/core/ServiceUnavailableError';
import {getClient, getLoadedCassandraDriver} from '@pkgs/cassandra/src/Client';
import {getClient, getLoadedCassandraDriver, getSerialConsistency} from '@pkgs/cassandra/src/Client';
import type cassandra from 'cassandra-driver';
const DEFAULT_MAX_PARTITION_KEYS_PER_QUERY = 100;
@@ -106,6 +106,13 @@ interface CassandraReadOptions {
consistency: 'all' | 'serial' | 'localQuorum';
}
function driverConsistencyOption(consistency: CassandraReadOptions['consistency'] | undefined): {consistency?: number} {
if (!consistency) return {};
const name = consistency === 'serial' ? getSerialConsistency() : consistency;
const value = getLoadedCassandraDriver()?.types.consistencies[name];
return value === undefined ? {} : {consistency: value};
}
async function collectSelectRows<T>(queryType: string, result: cassandra.types.ResultSet): Promise<Array<T>> {
if (queryType !== 'SELECT' || !result.pageState) {
return (result.rows ?? []) as Array<T>;
@@ -145,7 +152,7 @@ export async function executeQuery<T = Record<string, unknown>, P extends Cassan
try {
const result = await getClient().execute(cql, driverParams(bound), {
prepare: true,
...(readOptions ? {consistency: getLoadedCassandraDriver()?.types.consistencies[readOptions.consistency]} : {}),
...driverConsistencyOption(readOptions?.consistency),
});
const rows = await collectSelectRows<T>(meta.type, result);
if (isDev) {
@@ -344,7 +351,7 @@ async function executeBatch(
prepare: true,
logged: atomic,
counter: false,
...(consistency ? {consistency: getLoadedCassandraDriver()?.types.consistencies[consistency]} : {}),
...driverConsistencyOption(consistency),
};
const isDev = getIsDev();
const startTime = isDev ? performance.now() : 0;
+2
View File
@@ -455,6 +455,8 @@ export async function startWorkerMain(): Promise<void> {
port: Config.cassandra.port,
keyspace: Config.cassandra.keyspace,
localDc: Config.cassandra.localDc,
consistency: Config.cassandra.consistency,
serialConsistency: Config.cassandra.serialConsistency,
username: Config.cassandra.username || undefined,
password: Config.cassandra.password || undefined,
readTimeoutMs: BACKGROUND_READ_TIMEOUT_MS,
@@ -2788,6 +2788,14 @@ How many proxies in front of the push relay it trusts.
The stack runs Postgres only.
#### `FLUXER_CASSANDRA_ADDRESS_TRANSLATION`
How the Rust services reach the Cassandra nodes the driver discovers. `auto` sends every connection to the contact point when `FLUXER_CASSANDRA_HOSTS` lists one host, and uses the nodes' own addresses otherwise. `contact_point` always sends every connection to the first host. `none` always uses the nodes' own addresses, so each request can go to a node that holds the data. Use `none` when every node's address is reachable, such as inside Kubernetes. Defaults to `auto`.
#### `FLUXER_CASSANDRA_CONSISTENCY`
The consistency level for Cassandra reads and writes that don't set their own: `one`, `local_one`, `quorum`, `local_quorum`, `each_quorum` or `all`. Defaults to `local_quorum`.
#### `FLUXER_CASSANDRA_HOSTS`
The Cassandra hosts.
@@ -2798,7 +2806,7 @@ The Cassandra keyspace.
#### `FLUXER_CASSANDRA_LOCAL_DC`
The local Cassandra data centre.
The local Cassandra data centre. Requests go only to nodes in it, and `local_quorum` and `local_serial` count the replicas in it. When it's empty, the Rust services send requests to any data centre.
#### `FLUXER_CASSANDRA_PASSWORD`
@@ -2808,6 +2816,10 @@ The Cassandra password.
The Cassandra port.
#### `FLUXER_CASSANDRA_SERIAL_CONSISTENCY`
The consistency level for Cassandra lightweight transactions and the reads that check them: `serial` or `local_serial`. Defaults to `local_serial`.
#### `FLUXER_CASSANDRA_USERNAME`
The Cassandra username.
+4 -1
View File
@@ -577,11 +577,14 @@ var envVars = []envVar{
{"FLUXER_APP_STORE_PRIVATE_KEY_PATH", "hosted", "The path to the App Store Connect private key."},
{"FLUXER_APP_STORE_PRODUCTS", "hosted", "The App Store products and what they grant."},
{"FLUXER_BUILD_VERSION", "internal", "The older name for BUILD_VERSION, which only the admin and app-proxy services read when BUILD_VERSION is empty. Their images set BUILD_VERSION."},
{"FLUXER_CASSANDRA_ADDRESS_TRANSLATION", "cassandra", "How the Rust services reach the Cassandra nodes the driver discovers. `auto` sends every connection to the contact point when FLUXER_CASSANDRA_HOSTS lists one host, and uses the nodes' own addresses otherwise. `contact_point` always sends every connection to the first host. `none` always uses the nodes' own addresses, so each request can go to a node that holds the data. Use `none` when every node's address is reachable, such as inside Kubernetes. Defaults to `auto`."},
{"FLUXER_CASSANDRA_CONSISTENCY", "cassandra", "The consistency level for Cassandra reads and writes that don't set their own: `one`, `local_one`, `quorum`, `local_quorum`, `each_quorum` or `all`. Defaults to `local_quorum`."},
{"FLUXER_CASSANDRA_HOSTS", "cassandra", "The Cassandra hosts."},
{"FLUXER_CASSANDRA_KEYSPACE", "cassandra", "The Cassandra keyspace."},
{"FLUXER_CASSANDRA_LOCAL_DC", "cassandra", "The local Cassandra data centre."},
{"FLUXER_CASSANDRA_LOCAL_DC", "cassandra", "The local Cassandra data centre. Requests go only to nodes in it, and `local_quorum` and `local_serial` count the replicas in it. When it's empty, the Rust services send requests to any data centre."},
{"FLUXER_CASSANDRA_PASSWORD", "cassandra", "The Cassandra password."},
{"FLUXER_CASSANDRA_PORT", "cassandra", "The Cassandra port."},
{"FLUXER_CASSANDRA_SERIAL_CONSISTENCY", "cassandra", "The consistency level for Cassandra lightweight transactions and the reads that check them: `serial` or `local_serial`. Defaults to `local_serial`."},
{"FLUXER_CASSANDRA_USERNAME", "cassandra", "The Cassandra username."},
{"FLUXER_DISABLE_RATE_LIMITS", "dev", "Whether rate limits are off."},
{"FLUXER_DOCS_ENDPOINT", "docs", "The public address of the docs site."},
+150
View File
@@ -25,6 +25,10 @@ pub struct ServiceConfig {
pub scylla_keyspace: String,
pub scylla_username: Option<String>,
pub scylla_password: Option<String>,
pub scylla_local_dc: Option<String>,
pub scylla_consistency: CassandraConsistency,
pub scylla_serial_consistency: CassandraSerialConsistency,
pub scylla_address_translation: CassandraAddressTranslation,
pub postgres_url: Option<String>,
pub postgres_host: String,
pub postgres_port: u16,
@@ -52,6 +56,83 @@ pub enum DatabaseBackend {
Cassandra,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CassandraConsistency {
One,
LocalOne,
Quorum,
LocalQuorum,
EachQuorum,
All,
}
impl CassandraConsistency {
fn parse(value: Option<String>) -> anyhow::Result<Self> {
let Some(value) = value.filter(|v| !v.trim().is_empty()) else {
return Ok(Self::LocalQuorum);
};
Ok(match normalize_setting(&value).as_str() {
"one" => Self::One,
"local_one" => Self::LocalOne,
"quorum" => Self::Quorum,
"local_quorum" => Self::LocalQuorum,
"each_quorum" => Self::EachQuorum,
"all" => Self::All,
_ => anyhow::bail!(
"unsupported FLUXER_CASSANDRA_CONSISTENCY: {value} (use one, local_one, quorum, local_quorum, each_quorum or all)"
),
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CassandraSerialConsistency {
Serial,
LocalSerial,
}
impl CassandraSerialConsistency {
fn parse(value: Option<String>) -> anyhow::Result<Self> {
let Some(value) = value.filter(|v| !v.trim().is_empty()) else {
return Ok(Self::LocalSerial);
};
Ok(match normalize_setting(&value).as_str() {
"serial" => Self::Serial,
"local_serial" => Self::LocalSerial,
_ => anyhow::bail!(
"unsupported FLUXER_CASSANDRA_SERIAL_CONSISTENCY: {value} (use serial or local_serial)"
),
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CassandraAddressTranslation {
Auto,
ContactPoint,
None,
}
impl CassandraAddressTranslation {
fn parse(value: Option<String>) -> anyhow::Result<Self> {
let Some(value) = value.filter(|v| !v.trim().is_empty()) else {
return Ok(Self::Auto);
};
Ok(match normalize_setting(&value).as_str() {
"auto" => Self::Auto,
"contact_point" => Self::ContactPoint,
"none" => Self::None,
_ => anyhow::bail!(
"unsupported FLUXER_CASSANDRA_ADDRESS_TRANSLATION: {value} (use auto, contact_point or none)"
),
})
}
}
fn normalize_setting(value: &str) -> String {
value.trim().to_ascii_lowercase().replace('-', "_")
}
impl ServiceConfig {
#[cfg(test)]
pub(crate) fn for_test(mode: Mode, shard_id: u32, shard_count: u32) -> Self {
@@ -71,6 +152,10 @@ impl ServiceConfig {
scylla_keyspace: "fluxer".to_owned(),
scylla_username: None,
scylla_password: None,
scylla_local_dc: None,
scylla_consistency: CassandraConsistency::LocalQuorum,
scylla_serial_consistency: CassandraSerialConsistency::LocalSerial,
scylla_address_translation: CassandraAddressTranslation::Auto,
postgres_url: None,
postgres_host: "127.0.0.1".to_owned(),
postgres_port: 5432,
@@ -217,6 +302,19 @@ impl ServiceConfig {
.unwrap_or_else(|| "fluxer".to_owned()),
scylla_username: env.value("FLUXER_CASSANDRA_USERNAME"),
scylla_password: env.value("FLUXER_CASSANDRA_PASSWORD"),
scylla_local_dc: env
.value("FLUXER_CASSANDRA_LOCAL_DC")
.map(|dc| dc.trim().to_owned())
.filter(|dc| !dc.is_empty()),
scylla_consistency: CassandraConsistency::parse(
env.value("FLUXER_CASSANDRA_CONSISTENCY"),
)?,
scylla_serial_consistency: CassandraSerialConsistency::parse(
env.value("FLUXER_CASSANDRA_SERIAL_CONSISTENCY"),
)?,
scylla_address_translation: CassandraAddressTranslation::parse(
env.value("FLUXER_CASSANDRA_ADDRESS_TRANSLATION"),
)?,
postgres_url: env.value("FLUXER_POSTGRES_URL"),
postgres_host: env
.value("FLUXER_POSTGRES_HOST")
@@ -300,3 +398,55 @@ fn parse_bool(value: &str) -> anyhow::Result<bool> {
other => anyhow::bail!("invalid boolean value: {other}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn config_with(vars: &[(&str, &str)]) -> anyhow::Result<ServiceConfig> {
ServiceConfig::from_env_map(&EnvMap::from_pairs(vars.iter().copied()))
}
#[test]
fn cassandra_defaults_are_local_and_keep_contact_point_auto() {
let config = config_with(&[]).unwrap();
assert_eq!(config.scylla_local_dc, None);
assert_eq!(config.scylla_consistency, CassandraConsistency::LocalQuorum);
assert_eq!(
config.scylla_serial_consistency,
CassandraSerialConsistency::LocalSerial
);
assert_eq!(
config.scylla_address_translation,
CassandraAddressTranslation::Auto
);
}
#[test]
fn cassandra_settings_are_read_from_env() {
let config = config_with(&[
("FLUXER_CASSANDRA_LOCAL_DC", " ovh-lim "),
("FLUXER_CASSANDRA_CONSISTENCY", "LOCAL_ONE"),
("FLUXER_CASSANDRA_SERIAL_CONSISTENCY", "serial"),
("FLUXER_CASSANDRA_ADDRESS_TRANSLATION", "none"),
])
.unwrap();
assert_eq!(config.scylla_local_dc.as_deref(), Some("ovh-lim"));
assert_eq!(config.scylla_consistency, CassandraConsistency::LocalOne);
assert_eq!(
config.scylla_serial_consistency,
CassandraSerialConsistency::Serial
);
assert_eq!(
config.scylla_address_translation,
CassandraAddressTranslation::None
);
}
#[test]
fn unknown_cassandra_consistency_is_rejected() {
assert!(config_with(&[("FLUXER_CASSANDRA_CONSISTENCY", "two")]).is_err());
assert!(config_with(&[("FLUXER_CASSANDRA_SERIAL_CONSISTENCY", "quorum")]).is_err());
assert!(config_with(&[("FLUXER_CASSANDRA_ADDRESS_TRANSLATION", "nat")]).is_err());
}
}
+56 -3
View File
@@ -1,10 +1,15 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::config::{
CassandraAddressTranslation, CassandraConsistency, CassandraSerialConsistency,
};
use scylla::client::execution_profile::ExecutionProfile;
use scylla::client::session::Session;
use scylla::client::session_builder::SessionBuilder;
use scylla::errors::TranslationError;
use scylla::policies::address_translator::{AddressTranslator, UntranslatedPeer};
use scylla::policies::load_balancing::DefaultPolicy;
use scylla::statement::{Consistency, SerialConsistency};
use std::net::{SocketAddr, ToSocketAddrs};
use std::sync::Arc;
use std::time::Duration;
@@ -17,6 +22,10 @@ pub struct ScyllaConfig {
pub keyspace: String,
pub username: Option<String>,
pub password: Option<String>,
pub local_dc: Option<String>,
pub consistency: CassandraConsistency,
pub serial_consistency: CassandraSerialConsistency,
pub address_translation: CassandraAddressTranslation,
}
impl ScyllaConfig {
@@ -26,6 +35,10 @@ impl ScyllaConfig {
keyspace: config.scylla_keyspace.clone(),
username: config.scylla_username.clone(),
password: config.scylla_password.clone(),
local_dc: config.scylla_local_dc.clone(),
consistency: config.scylla_consistency,
serial_consistency: config.scylla_serial_consistency,
address_translation: config.scylla_address_translation,
}
}
}
@@ -37,14 +50,15 @@ pub async fn connect(config: &ScyllaConfig) -> anyhow::Result<Arc<Session>> {
let mut builder = SessionBuilder::new()
.known_nodes(config.hosts.iter().map(String::as_str))
.default_execution_profile_handle(execution_profile().into_handle())
.default_execution_profile_handle(execution_profile(config).into_handle())
.use_keyspace(config.keyspace.clone(), false);
if let Some(username) = &config.username {
builder = builder.user(username, config.password.as_deref().unwrap_or_default());
}
if config.hosts.len() == 1 {
let translate_to_contact_point = translates_to_contact_point(config);
if translate_to_contact_point {
let target = resolve_contact_point(&config.hosts[0])?;
builder = builder.address_translator(Arc::new(ContactPointTranslator { target }));
}
@@ -53,18 +67,57 @@ pub async fn connect(config: &ScyllaConfig) -> anyhow::Result<Arc<Session>> {
tracing::info!(
keyspace = config.keyspace,
hosts = ?config.hosts,
local_dc = config.local_dc.as_deref().unwrap_or(""),
consistency = ?config.consistency,
serial_consistency = ?config.serial_consistency,
translate_to_contact_point,
request_timeout_ms = REQUEST_TIMEOUT.as_millis(),
"connected to ScyllaDB"
);
Ok(session)
}
fn execution_profile() -> ExecutionProfile {
fn translates_to_contact_point(config: &ScyllaConfig) -> bool {
match config.address_translation {
CassandraAddressTranslation::Auto => config.hosts.len() == 1,
CassandraAddressTranslation::ContactPoint => true,
CassandraAddressTranslation::None => false,
}
}
fn execution_profile(config: &ScyllaConfig) -> ExecutionProfile {
let mut policy = DefaultPolicy::builder().token_aware(true);
if let Some(dc) = &config.local_dc {
policy = policy
.prefer_datacenter(dc.clone())
.permit_dc_failover(false);
}
ExecutionProfile::builder()
.request_timeout(Some(REQUEST_TIMEOUT))
.consistency(driver_consistency(config.consistency))
.serial_consistency(Some(driver_serial_consistency(config.serial_consistency)))
.load_balancing_policy(policy.build())
.build()
}
fn driver_consistency(consistency: CassandraConsistency) -> Consistency {
match consistency {
CassandraConsistency::One => Consistency::One,
CassandraConsistency::LocalOne => Consistency::LocalOne,
CassandraConsistency::Quorum => Consistency::Quorum,
CassandraConsistency::LocalQuorum => Consistency::LocalQuorum,
CassandraConsistency::EachQuorum => Consistency::EachQuorum,
CassandraConsistency::All => Consistency::All,
}
}
fn driver_serial_consistency(consistency: CassandraSerialConsistency) -> SerialConsistency {
match consistency {
CassandraSerialConsistency::Serial => SerialConsistency::Serial,
CassandraSerialConsistency::LocalSerial => SerialConsistency::LocalSerial,
}
}
struct ContactPointTranslator {
target: SocketAddr,
}
+2
View File
@@ -107,6 +107,8 @@ function defaultConfig(): MasterConfig {
port: 9042,
keyspace: 'fluxer',
local_dc: 'datacenter1',
consistency: 'local_quorum',
serial_consistency: 'local_serial',
username: '',
password: '',
},
+2
View File
@@ -81,6 +81,8 @@ export interface MasterConfig {
port: number;
keyspace: string;
local_dc: string;
consistency: string;
serial_consistency: string;
username: string;
password: string;
};
@@ -38,6 +38,8 @@ const NAMED_FLUXER_ENV_OVERRIDES: Record<string, NamedEnvOverride> = {
FLUXER_CASSANDRA_PORT: {path: ['database', 'cassandra', 'port'], parse: parseInteger},
FLUXER_CASSANDRA_KEYSPACE: {path: ['database', 'cassandra', 'keyspace']},
FLUXER_CASSANDRA_LOCAL_DC: {path: ['database', 'cassandra', 'local_dc']},
FLUXER_CASSANDRA_CONSISTENCY: {path: ['database', 'cassandra', 'consistency']},
FLUXER_CASSANDRA_SERIAL_CONSISTENCY: {path: ['database', 'cassandra', 'serial_consistency']},
FLUXER_CASSANDRA_USERNAME: {path: ['database', 'cassandra', 'username']},
FLUXER_CASSANDRA_PASSWORD: {path: ['database', 'cassandra', 'password']},
FLUXER_POSTGRES_URL: {path: ['database', 'postgres', 'url']},