feat(cassandra): complete native agent migration
This commit is contained in:
17 files changed
+1299
-356
No files matched your search
@@ -566,6 +566,47 @@ jobs:
|
|||||||
run: CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o /tmp/dbx-agent-vastbase-linux-x64 .
|
run: CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o /tmp/dbx-agent-vastbase-linux-x64 .
|
||||||
working-directory: agents/drivers/vastbase-go
|
working-directory: agents/drivers/vastbase-go
|
||||||
|
|
||||||
|
- name: Cassandra native agent integration tests
|
||||||
|
shell: bash
|
||||||
|
working-directory: agents/drivers/cassandra-go
|
||||||
|
run: |
|
||||||
|
set -euo pipefail
|
||||||
|
for version in 3.11.19 5.0.6; do
|
||||||
|
name="dbx-cassandra-${version//./-}"
|
||||||
|
docker rm -fv "$name" >/dev/null 2>&1 || true
|
||||||
|
docker run -d --name "$name" \
|
||||||
|
-e CASSANDRA_CLUSTER_NAME="DBX Cassandra CI $version" \
|
||||||
|
-e CASSANDRA_DC=dc1 \
|
||||||
|
-e CASSANDRA_RACK=rack1 \
|
||||||
|
-e CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch \
|
||||||
|
-e CASSANDRA_NUM_TOKENS=16 \
|
||||||
|
-e MAX_HEAP_SIZE=512M \
|
||||||
|
-e HEAP_NEWSIZE=100M \
|
||||||
|
-p 9042:9042 \
|
||||||
|
"cassandra:$version"
|
||||||
|
cleanup() {
|
||||||
|
docker rm -fv "$name" >/dev/null 2>&1 || true
|
||||||
|
}
|
||||||
|
trap cleanup EXIT
|
||||||
|
ready=false
|
||||||
|
for _ in $(seq 1 100); do
|
||||||
|
if docker exec "$name" cqlsh -e 'SELECT release_version FROM system.local' >/dev/null 2>&1; then
|
||||||
|
ready=true
|
||||||
|
break
|
||||||
|
fi
|
||||||
|
sleep 3
|
||||||
|
done
|
||||||
|
if [ "$ready" != "true" ]; then
|
||||||
|
docker logs "$name"
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
CASSANDRA_TEST_HOST=127.0.0.1 \
|
||||||
|
CASSANDRA_TEST_PORT=9042 \
|
||||||
|
go test -run '^TestCassandraIntegration$' -count=1 ./...
|
||||||
|
cleanup
|
||||||
|
trap - EXIT
|
||||||
|
done
|
||||||
|
|
||||||
- name: RabbitMQ native agent integration tests
|
- name: RabbitMQ native agent integration tests
|
||||||
shell: bash
|
shell: bash
|
||||||
working-directory: agents/drivers/rabbitmq
|
working-directory: agents/drivers/rabbitmq
|
||||||
|
|||||||
@@ -0,0 +1,61 @@
|
|||||||
|
# Cassandra native Agent
|
||||||
|
|
||||||
|
The Cassandra Agent uses Apache `cassandra-gocql-driver` and implements the DBX
|
||||||
|
multi-session JSON-RPC protocol without a JVM.
|
||||||
|
|
||||||
|
## Compatibility
|
||||||
|
|
||||||
|
- Native protocol versions: v3-v5
|
||||||
|
- Declared server range: Apache Cassandra 2.1+
|
||||||
|
- Live validation: 2.2.19, 3.11.19, 4.1.10, and 5.0.6
|
||||||
|
- Authentication: username/password
|
||||||
|
- TLS: CA verification, optional client certificate/key, hostname verification
|
||||||
|
- Metadata: keyspaces, tables, columns, indexes, CQL table DDL, completion search
|
||||||
|
- Queries: legacy string result values, paging, cancellation, logged and unlogged batches
|
||||||
|
|
||||||
|
The Agent accepts both normal DBX connection fields and Cassandra JDBC-style
|
||||||
|
connection strings, including the wrapper's `host1--host2:9042` contact-point
|
||||||
|
syntax.
|
||||||
|
|
||||||
|
## JDBC URL parameter mapping
|
||||||
|
|
||||||
|
| JDBC parameter | Native behavior |
|
||||||
|
| --- | --- |
|
||||||
|
| `consistency` | GoCQL consistency |
|
||||||
|
| `fetchsize` | default page size |
|
||||||
|
| `retries` | retry/reconnection attempt count |
|
||||||
|
| `loadbalancing` | default, round-robin, DC-aware, or token-aware built-in policy |
|
||||||
|
| `localdatacenter` | DC-aware host selection |
|
||||||
|
| `retry` | default/simple, fallthrough, downgrading, or exponential built-in policy |
|
||||||
|
| `reconnection` | constant or exponential reconnection policy |
|
||||||
|
| `debug` | GoCQL debug logging to stderr |
|
||||||
|
| `enablessl` | TLS enablement |
|
||||||
|
| `sslenginefactory` | the standard `DefaultSslEngineFactory` maps to native TLS |
|
||||||
|
| `hostnameverification` | TLS hostname verification; enabled by default |
|
||||||
|
| `user`, `password` | password authentication |
|
||||||
|
| `requesttimeout`, `connecttimeout` | request and connection deadlines |
|
||||||
|
| `tcpnodelay`, `keepalive` | native TCP socket options |
|
||||||
|
| `compliancemode` | accepted; JDBC-only `java.sql` behavior is not applicable to JSON-RPC |
|
||||||
|
|
||||||
|
Java implementation hooks do not have a safe native equivalent. The Agent
|
||||||
|
returns a targeted connection error for `configfile`, `usekrb5=true`,
|
||||||
|
`secureconnectbundle`, custom `sslenginefactory` classes, and custom policy
|
||||||
|
classes. Translate Java HOCON settings to the supported URL parameters before
|
||||||
|
migrating a connection.
|
||||||
|
|
||||||
|
## Integration test
|
||||||
|
|
||||||
|
```bash
|
||||||
|
CASSANDRA_TEST_HOST=127.0.0.1 \
|
||||||
|
CASSANDRA_TEST_PORT=9042 \
|
||||||
|
CASSANDRA_TEST_USERNAME=cassandra \
|
||||||
|
CASSANDRA_TEST_PASSWORD=cassandra \
|
||||||
|
go test -run TestCassandraIntegration -v
|
||||||
|
```
|
||||||
|
|
||||||
|
Optional variables include `CASSANDRA_TEST_URL_PARAMS`, `CASSANDRA_TEST_SSL`,
|
||||||
|
`CASSANDRA_TEST_CA_CERT_PATH`, `CASSANDRA_TEST_CLIENT_CERT_PATH`, and
|
||||||
|
`CASSANDRA_TEST_CLIENT_KEY_PATH`.
|
||||||
|
|
||||||
|
See `bench/README.md` for the archived JDBC comparison workflow and measured
|
||||||
|
Cassandra 4.1.10 results.
|
||||||
@@ -0,0 +1,61 @@
|
|||||||
|
# Cassandra Agent benchmark
|
||||||
|
|
||||||
|
This benchmark compares the same DBX JSON-RPC operations through the native
|
||||||
|
Apache `cassandra-gocql-driver` Agent and the archived Cassandra JDBC Agent.
|
||||||
|
It measures process startup, connection creation, RSS, latency, throughput,
|
||||||
|
artifact size, and shutdown behavior.
|
||||||
|
|
||||||
|
Each connection sample uses a fresh Agent process so JDBC runtime pooling cannot
|
||||||
|
turn later samples into warm reconnects. Query workloads use one persistent,
|
||||||
|
already-connected process per candidate.
|
||||||
|
|
||||||
|
## Prepare the fixture
|
||||||
|
|
||||||
|
The default workload expects `dbx_native_test.all_types` with at least 100 rows
|
||||||
|
and an integer primary key named `id`. Override the SQL variables below when
|
||||||
|
using another schema.
|
||||||
|
|
||||||
|
## Build the native Agent
|
||||||
|
|
||||||
|
From `agents/`:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
go build -o /tmp/dbx-cassandra-bench/cassandra-go ./drivers/cassandra-go
|
||||||
|
```
|
||||||
|
|
||||||
|
Keep an archived JDBC Agent JAR as the baseline. The production Cassandra
|
||||||
|
module publishes only the native executable.
|
||||||
|
|
||||||
|
## Run
|
||||||
|
|
||||||
|
```bash
|
||||||
|
GO_AGENT=/tmp/dbx-cassandra-bench/cassandra-go \
|
||||||
|
JDBC_AGENT_JAR=/tmp/dbx-cassandra-bench/dbx-agent-cassandra.jar \
|
||||||
|
CASSANDRA_HOST=127.0.0.1 \
|
||||||
|
CASSANDRA_PORT=9042 \
|
||||||
|
CASSANDRA_KEYSPACE=dbx_native_test \
|
||||||
|
python3 drivers/cassandra-go/bench/agent_compare.py \
|
||||||
|
> /tmp/dbx-cassandra-bench/result.json
|
||||||
|
```
|
||||||
|
|
||||||
|
If Java is only available in a container, provide the full interactive command:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
JDBC_AGENT_COMMAND='docker run --rm -i --name dbx-cassandra-jdbc-bench -v /tmp/dbx-cassandra-bench:/bench:ro eclipse-temurin:21-jre java -jar /bench/dbx-agent-cassandra.jar'
|
||||||
|
JDBC_RSS_COMMAND="docker inspect --format '{{.State.Pid}}' dbx-cassandra-jdbc-bench | xargs -I{} awk '/VmRSS/ {print \$2}' /proc/{}/status"
|
||||||
|
```
|
||||||
|
|
||||||
|
## Configuration
|
||||||
|
|
||||||
|
- `BENCH_CANDIDATES`: `go,jdbc` by default
|
||||||
|
- `BENCH_STARTUPS`: startup samples, default `10`
|
||||||
|
- `BENCH_CONNECTS`: connection samples, default `10`
|
||||||
|
- `BENCH_WARMUPS`: warmups before each workload, default `20`
|
||||||
|
- `CASSANDRA_USERNAME`, `CASSANDRA_PASSWORD`, `CASSANDRA_URL_PARAMS`
|
||||||
|
- `CASSANDRA_SSL`, `CASSANDRA_CA_CERT_PATH`, `CASSANDRA_CLIENT_CERT_PATH`, `CASSANDRA_CLIENT_KEY_PATH`
|
||||||
|
- `BENCH_SELECT_ONE_SQL`, `BENCH_DECODE_SQL`, `BENCH_PAGE_SQL`
|
||||||
|
- `BENCH_SELECT_ONE_COUNT`, `BENCH_DECODE_COUNT`, `BENCH_LIST_TABLES_COUNT`, `BENCH_PAGE_COUNT`
|
||||||
|
|
||||||
|
Run both candidates on the same host against the same Cassandra instance. Do
|
||||||
|
not compare a local native Agent with a remote JDBC Agent or change the query
|
||||||
|
shape between candidates.
|
||||||
+328
@@ -0,0 +1,328 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import shlex
|
||||||
|
import statistics
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True)
|
||||||
|
class Candidate:
|
||||||
|
name: str
|
||||||
|
command: list[str]
|
||||||
|
artifact: Path
|
||||||
|
rss_command: str = ""
|
||||||
|
|
||||||
|
|
||||||
|
class AgentProcess:
|
||||||
|
def __init__(self, candidate: Candidate):
|
||||||
|
self.candidate = candidate
|
||||||
|
self.process = subprocess.Popen(
|
||||||
|
candidate.command,
|
||||||
|
stdin=subprocess.PIPE,
|
||||||
|
stdout=subprocess.PIPE,
|
||||||
|
stderr=subprocess.PIPE,
|
||||||
|
text=True,
|
||||||
|
bufsize=1,
|
||||||
|
)
|
||||||
|
self.request_id = 0
|
||||||
|
self.stderr_lines: list[str] = []
|
||||||
|
threading.Thread(target=self._drain_stderr, daemon=True).start()
|
||||||
|
self._wait_ready()
|
||||||
|
|
||||||
|
def _drain_stderr(self) -> None:
|
||||||
|
assert self.process.stderr is not None
|
||||||
|
for line in self.process.stderr:
|
||||||
|
self.stderr_lines.append(line.rstrip())
|
||||||
|
|
||||||
|
def _wait_ready(self) -> None:
|
||||||
|
assert self.process.stdout is not None
|
||||||
|
deadline = time.monotonic() + env_float("BENCH_READY_TIMEOUT", 30.0)
|
||||||
|
while time.monotonic() < deadline:
|
||||||
|
line = self.process.stdout.readline()
|
||||||
|
if line == "" and self.process.poll() is not None:
|
||||||
|
raise RuntimeError(self._failure("agent exited before ready"))
|
||||||
|
try:
|
||||||
|
if json.loads(line).get("ready") is True:
|
||||||
|
return
|
||||||
|
except (json.JSONDecodeError, AttributeError):
|
||||||
|
continue
|
||||||
|
raise TimeoutError(self._failure("timed out waiting for agent readiness"))
|
||||||
|
|
||||||
|
def call(self, method: str, params: dict | None = None) -> dict:
|
||||||
|
self.request_id += 1
|
||||||
|
request = {
|
||||||
|
"jsonrpc": "2.0",
|
||||||
|
"id": self.request_id,
|
||||||
|
"method": method,
|
||||||
|
"params": params or {},
|
||||||
|
}
|
||||||
|
assert self.process.stdin is not None
|
||||||
|
assert self.process.stdout is not None
|
||||||
|
self.process.stdin.write(json.dumps(request, separators=(",", ":")) + "\n")
|
||||||
|
self.process.stdin.flush()
|
||||||
|
while True:
|
||||||
|
line = self.process.stdout.readline()
|
||||||
|
if line == "" and self.process.poll() is not None:
|
||||||
|
raise RuntimeError(self._failure(f"agent exited during {method}"))
|
||||||
|
try:
|
||||||
|
response = json.loads(line)
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
continue
|
||||||
|
if response.get("id") != self.request_id:
|
||||||
|
continue
|
||||||
|
if response.get("error") is not None:
|
||||||
|
raise RuntimeError(f"{self.candidate.name} {method}: {json.dumps(response['error'], ensure_ascii=False)}")
|
||||||
|
return response.get("result")
|
||||||
|
|
||||||
|
def rss_kib(self) -> int:
|
||||||
|
if self.candidate.rss_command:
|
||||||
|
output = subprocess.check_output(self.candidate.rss_command, shell=True, text=True).strip()
|
||||||
|
return int(output)
|
||||||
|
output = subprocess.check_output(
|
||||||
|
["ps", "-o", "rss=", "-p", str(self.process.pid)],
|
||||||
|
text=True,
|
||||||
|
).strip()
|
||||||
|
return int(output or "0")
|
||||||
|
|
||||||
|
def close(self) -> bool:
|
||||||
|
if self.process.poll() is not None:
|
||||||
|
return True
|
||||||
|
try:
|
||||||
|
self.call("shutdown")
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
try:
|
||||||
|
self.process.wait(timeout=3)
|
||||||
|
return True
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
self.process.terminate()
|
||||||
|
try:
|
||||||
|
self.process.wait(timeout=2)
|
||||||
|
except subprocess.TimeoutExpired:
|
||||||
|
self.process.kill()
|
||||||
|
self.process.wait(timeout=5)
|
||||||
|
return False
|
||||||
|
|
||||||
|
def _failure(self, message: str) -> str:
|
||||||
|
stderr = "\n".join(self.stderr_lines[-20:])
|
||||||
|
return f"{self.candidate.name}: {message}\n{stderr}".rstrip()
|
||||||
|
|
||||||
|
|
||||||
|
def main() -> None:
|
||||||
|
candidates = configured_candidates()
|
||||||
|
connection = connection_params()
|
||||||
|
startup_iterations = env_int("BENCH_STARTUPS", 10)
|
||||||
|
connect_iterations = env_int("BENCH_CONNECTS", 10)
|
||||||
|
warmups = env_int("BENCH_WARMUPS", 20)
|
||||||
|
workloads = configured_workloads(connection["database"])
|
||||||
|
results = []
|
||||||
|
|
||||||
|
for candidate in candidates:
|
||||||
|
startup_samples = benchmark_startup(candidate, startup_iterations)
|
||||||
|
connect_samples = benchmark_connect(candidate, connection, connect_iterations)
|
||||||
|
process = AgentProcess(candidate)
|
||||||
|
shutdown_clean = False
|
||||||
|
try:
|
||||||
|
process.call("connect", connection)
|
||||||
|
rss_kib = process.rss_kib()
|
||||||
|
workload_results = [benchmark_workload(process, workload, warmups) for workload in workloads]
|
||||||
|
process.call("disconnect")
|
||||||
|
finally:
|
||||||
|
shutdown_clean = process.close()
|
||||||
|
results.append(
|
||||||
|
{
|
||||||
|
"candidate": candidate.name,
|
||||||
|
"command": candidate.command,
|
||||||
|
"artifact_bytes": candidate.artifact.stat().st_size,
|
||||||
|
"startup_ms": statistics.median(startup_samples),
|
||||||
|
"startup_samples_ms": startup_samples,
|
||||||
|
"connect_ms": statistics.median(connect_samples),
|
||||||
|
"connect_samples_ms": connect_samples,
|
||||||
|
"rss_kib": rss_kib,
|
||||||
|
"shutdown_exited_within_3s": shutdown_clean,
|
||||||
|
"workloads": workload_results,
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
output = {
|
||||||
|
"host": os.uname().nodename,
|
||||||
|
"server": env_default("CASSANDRA_SERVER", f"{connection['host']}:{connection['port']}"),
|
||||||
|
"keyspace": connection["database"],
|
||||||
|
"startup_iterations": startup_iterations,
|
||||||
|
"connect_iterations": connect_iterations,
|
||||||
|
"warmups": warmups,
|
||||||
|
"results": results,
|
||||||
|
}
|
||||||
|
json.dump(output, sys.stdout, ensure_ascii=False, indent=2)
|
||||||
|
sys.stdout.write("\n")
|
||||||
|
|
||||||
|
|
||||||
|
def configured_candidates() -> list[Candidate]:
|
||||||
|
selected = {item.strip() for item in env_default("BENCH_CANDIDATES", "go,jdbc").split(",") if item.strip()}
|
||||||
|
candidates = []
|
||||||
|
if "go" in selected:
|
||||||
|
artifact = required_path("GO_AGENT")
|
||||||
|
candidates.append(Candidate("go-native", [str(artifact)], artifact, os.getenv("GO_RSS_COMMAND", "")))
|
||||||
|
if "jdbc" in selected:
|
||||||
|
artifact = required_path("JDBC_AGENT_JAR")
|
||||||
|
raw_command = os.getenv("JDBC_AGENT_COMMAND", "")
|
||||||
|
command = shlex.split(raw_command) if raw_command else [env_default("JAVA_BIN", "java"), "-jar", str(artifact)]
|
||||||
|
candidates.append(Candidate("jdbc-java", command, artifact, os.getenv("JDBC_RSS_COMMAND", "")))
|
||||||
|
if not candidates:
|
||||||
|
raise ValueError("BENCH_CANDIDATES selected no candidates")
|
||||||
|
return candidates
|
||||||
|
|
||||||
|
|
||||||
|
def connection_params() -> dict:
|
||||||
|
return {
|
||||||
|
"host": env_default("CASSANDRA_HOST", "127.0.0.1"),
|
||||||
|
"port": env_int("CASSANDRA_PORT", 9042),
|
||||||
|
"database": env_default("CASSANDRA_KEYSPACE", "dbx_native_test"),
|
||||||
|
"username": os.getenv("CASSANDRA_USERNAME", ""),
|
||||||
|
"password": os.getenv("CASSANDRA_PASSWORD", ""),
|
||||||
|
"url_params": os.getenv("CASSANDRA_URL_PARAMS", ""),
|
||||||
|
"connection_string": os.getenv("CASSANDRA_CONNECTION_STRING", ""),
|
||||||
|
"ssl": env_bool("CASSANDRA_SSL", False),
|
||||||
|
"ca_cert_path": os.getenv("CASSANDRA_CA_CERT_PATH", ""),
|
||||||
|
"client_cert_path": os.getenv("CASSANDRA_CLIENT_CERT_PATH", ""),
|
||||||
|
"client_key_path": os.getenv("CASSANDRA_CLIENT_KEY_PATH", ""),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def configured_workloads(keyspace: str) -> list[dict]:
|
||||||
|
table = env_default("CASSANDRA_BENCH_TABLE", "all_types")
|
||||||
|
qualified = f'"{keyspace}"."{table}"'
|
||||||
|
return [
|
||||||
|
{
|
||||||
|
"name": "select_one",
|
||||||
|
"method": "execute_query",
|
||||||
|
"params": {"sql": env_default("BENCH_SELECT_ONE_SQL", f"SELECT id, txt FROM {qualified} WHERE id = 1"), "schema": keyspace, "maxRows": 1},
|
||||||
|
"count": env_int("BENCH_SELECT_ONE_COUNT", 1000),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"name": "decode_all_types",
|
||||||
|
"method": "execute_query",
|
||||||
|
"params": {"sql": env_default("BENCH_DECODE_SQL", f"SELECT * FROM {qualified} WHERE id = 1"), "schema": keyspace, "maxRows": 1},
|
||||||
|
"count": env_int("BENCH_DECODE_COUNT", 500),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"name": "list_tables",
|
||||||
|
"method": "list_tables",
|
||||||
|
"params": {"schema": keyspace},
|
||||||
|
"count": env_int("BENCH_LIST_TABLES_COUNT", 500),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"name": "page_100",
|
||||||
|
"method": "execute_query_page",
|
||||||
|
"params": {
|
||||||
|
"sql": env_default("BENCH_PAGE_SQL", f"SELECT id, txt FROM {qualified}"),
|
||||||
|
"schema": keyspace,
|
||||||
|
"maxRows": 100,
|
||||||
|
"pageSize": 100,
|
||||||
|
},
|
||||||
|
"count": env_int("BENCH_PAGE_COUNT", 200),
|
||||||
|
},
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
def benchmark_startup(candidate: Candidate, iterations: int) -> list[float]:
|
||||||
|
samples = []
|
||||||
|
for _ in range(iterations):
|
||||||
|
start = time.perf_counter()
|
||||||
|
process = AgentProcess(candidate)
|
||||||
|
samples.append((time.perf_counter() - start) * 1000)
|
||||||
|
process.close()
|
||||||
|
return samples
|
||||||
|
|
||||||
|
|
||||||
|
def benchmark_connect(candidate: Candidate, connection: dict, iterations: int) -> list[float]:
|
||||||
|
samples = []
|
||||||
|
for _ in range(iterations):
|
||||||
|
process = AgentProcess(candidate)
|
||||||
|
try:
|
||||||
|
start = time.perf_counter()
|
||||||
|
process.call("connect", connection)
|
||||||
|
samples.append((time.perf_counter() - start) * 1000)
|
||||||
|
finally:
|
||||||
|
process.close()
|
||||||
|
return samples
|
||||||
|
|
||||||
|
|
||||||
|
def benchmark_workload(process: AgentProcess, workload: dict, warmups: int) -> dict:
|
||||||
|
for _ in range(warmups):
|
||||||
|
process.call(workload["method"], workload["params"])
|
||||||
|
samples = []
|
||||||
|
start = time.perf_counter()
|
||||||
|
for _ in range(workload["count"]):
|
||||||
|
operation_start = time.perf_counter()
|
||||||
|
process.call(workload["method"], workload["params"])
|
||||||
|
samples.append((time.perf_counter() - operation_start) * 1000)
|
||||||
|
elapsed = time.perf_counter() - start
|
||||||
|
ordered = sorted(samples)
|
||||||
|
return {
|
||||||
|
"name": workload["name"],
|
||||||
|
"count": workload["count"],
|
||||||
|
"elapsed_ms": elapsed * 1000,
|
||||||
|
"ops_per_sec": workload["count"] / elapsed,
|
||||||
|
"mean_ms": statistics.mean(samples),
|
||||||
|
"p50_ms": percentile(ordered, 0.50),
|
||||||
|
"p95_ms": percentile(ordered, 0.95),
|
||||||
|
"p99_ms": percentile(ordered, 0.99),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def percentile(values: list[float], fraction: float) -> float:
|
||||||
|
if not values:
|
||||||
|
return 0.0
|
||||||
|
index = min(len(values) - 1, max(0, round((len(values) - 1) * fraction)))
|
||||||
|
return values[index]
|
||||||
|
|
||||||
|
|
||||||
|
def required_path(name: str) -> Path:
|
||||||
|
value = os.getenv(name, "")
|
||||||
|
if not value:
|
||||||
|
raise ValueError(f"{name} is required")
|
||||||
|
path = Path(value).expanduser().resolve()
|
||||||
|
if not path.is_file():
|
||||||
|
raise FileNotFoundError(path)
|
||||||
|
return path
|
||||||
|
|
||||||
|
|
||||||
|
def env_default(name: str, fallback: str) -> str:
|
||||||
|
return os.getenv(name, "") or fallback
|
||||||
|
|
||||||
|
|
||||||
|
def env_int(name: str, fallback: int) -> int:
|
||||||
|
value = int(env_default(name, str(fallback)))
|
||||||
|
if value < 1:
|
||||||
|
raise ValueError(f"{name} must be positive")
|
||||||
|
return value
|
||||||
|
|
||||||
|
|
||||||
|
def env_float(name: str, fallback: float) -> float:
|
||||||
|
value = float(env_default(name, str(fallback)))
|
||||||
|
if value <= 0:
|
||||||
|
raise ValueError(f"{name} must be positive")
|
||||||
|
return value
|
||||||
|
|
||||||
|
|
||||||
|
def env_bool(name: str, fallback: bool) -> bool:
|
||||||
|
raw = os.getenv(name)
|
||||||
|
if raw is None or raw == "":
|
||||||
|
return fallback
|
||||||
|
normalized = raw.strip().lower()
|
||||||
|
if normalized in {"1", "true", "yes", "on"}:
|
||||||
|
return True
|
||||||
|
if normalized in {"0", "false", "no", "off"}:
|
||||||
|
return False
|
||||||
|
raise ValueError(f"{name} must be a boolean")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
@@ -0,0 +1,36 @@
|
|||||||
|
{
|
||||||
|
"date": "2026-08-03",
|
||||||
|
"host": "oss-rainyun-01",
|
||||||
|
"cassandra": "4.1.10",
|
||||||
|
"method": "five cold-process startup and connection samples; persistent process for query workloads",
|
||||||
|
"results": [
|
||||||
|
{
|
||||||
|
"candidate": "go-native",
|
||||||
|
"startup_ms": 8.994690957479179,
|
||||||
|
"connect_ms": 33.21323194541037,
|
||||||
|
"rss_kib": 10352,
|
||||||
|
"artifact_bytes": 6750370,
|
||||||
|
"shutdown_exited_within_3s": true,
|
||||||
|
"workloads": [
|
||||||
|
{"name": "select_one", "count": 1000, "elapsed_ms": 1940.8286979887635, "ops_per_sec": 515.2438239584345, "mean_ms": 1.9388069859705865, "p50_ms": 1.9103229278698564, "p95_ms": 2.221024944446981, "p99_ms": 2.3676720447838306},
|
||||||
|
{"name": "decode_all_types", "count": 500, "elapsed_ms": 1079.476205050014, "ops_per_sec": 463.18760678641746, "mean_ms": 2.156704908935353, "p50_ms": 2.141958102583885, "p95_ms": 2.4329390143975616, "p99_ms": 2.7680869679898024},
|
||||||
|
{"name": "list_tables", "count": 500, "elapsed_ms": 57.42691201157868, "ops_per_sec": 8706.71924513698, "mean_ms": 0.11419291398487985, "p50_ms": 0.10622991248965263, "p95_ms": 0.1487070694565773, "p99_ms": 0.19879091996699572},
|
||||||
|
{"name": "page_100", "count": 200, "elapsed_ms": 984.7569830017164, "ops_per_sec": 203.09579261917395, "mean_ms": 4.921203925041482, "p50_ms": 4.922428051941097, "p95_ms": 6.079918937757611, "p99_ms": 7.303814985789359}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"candidate": "jdbc-java",
|
||||||
|
"startup_ms": 657.9867920372635,
|
||||||
|
"connect_ms": 1778.3896300243214,
|
||||||
|
"rss_kib": 166232,
|
||||||
|
"artifact_bytes": 22984056,
|
||||||
|
"shutdown_exited_within_3s": false,
|
||||||
|
"workloads": [
|
||||||
|
{"name": "select_one", "count": 1000, "elapsed_ms": 3868.2536740088835, "ops_per_sec": 258.51458675502147, "mean_ms": 3.865854301955551, "p50_ms": 3.6270120181143284, "p95_ms": 5.733568919822574, "p99_ms": 7.344924029894173},
|
||||||
|
{"name": "decode_all_types", "count": 500, "elapsed_ms": 2014.9188039358705, "ops_per_sec": 248.14895718046694, "mean_ms": 4.0274618696421385, "p50_ms": 3.9998559514060616, "p95_ms": 4.94410190731287, "p99_ms": 5.3489640122279525},
|
||||||
|
{"name": "list_tables", "count": 500, "elapsed_ms": 763.6687039630488, "ops_per_sec": 654.7341764894339, "mean_ms": 1.5251681823283434, "p50_ms": 1.494601950980723, "p95_ms": 1.9315499812364578, "p99_ms": 2.339883940294385},
|
||||||
|
{"name": "page_100", "count": 200, "elapsed_ms": 8309.039836982265, "ops_per_sec": 24.070169829952025, "mean_ms": 41.53980694070924, "p50_ms": 42.0777719700709, "p95_ms": 51.87095201108605, "p99_ms": 57.71494994405657}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
@@ -31,23 +31,37 @@ type cassandraConfig struct {
|
|||||||
clientCertPath string
|
clientCertPath string
|
||||||
clientKeyPath string
|
clientKeyPath string
|
||||||
hostVerification bool
|
hostVerification bool
|
||||||
|
tcpNoDelay bool
|
||||||
|
keepAlive bool
|
||||||
|
debug bool
|
||||||
|
retryPolicy string
|
||||||
|
retryCount int
|
||||||
|
reconnectionPolicy string
|
||||||
|
reconnectionBaseDelay time.Duration
|
||||||
|
reconnectionMaxDelay time.Duration
|
||||||
|
loadBalancingPolicy string
|
||||||
disableInitialHostLookup bool
|
disableInitialHostLookup bool
|
||||||
}
|
}
|
||||||
|
|
||||||
func parseCassandraConfig(cp connectParams) (cassandraConfig, error) {
|
func parseCassandraConfig(cp connectParams) (cassandraConfig, error) {
|
||||||
config := cassandraConfig{
|
config := cassandraConfig{
|
||||||
port: 9042,
|
port: 9042,
|
||||||
keyspace: strings.TrimSpace(cp.Database),
|
keyspace: strings.TrimSpace(cp.Database),
|
||||||
username: cp.Username,
|
username: cp.Username,
|
||||||
password: cp.Password,
|
password: cp.Password,
|
||||||
requestTimeout: 11 * time.Second,
|
requestTimeout: 11 * time.Second,
|
||||||
connectTimeout: defaultConnectTimeout,
|
connectTimeout: defaultConnectTimeout,
|
||||||
numConnections: 2,
|
numConnections: 2,
|
||||||
pageSize: 5000,
|
pageSize: 5000,
|
||||||
ssl: cp.SSL,
|
ssl: cp.SSL,
|
||||||
caCertPath: cp.CACertPath,
|
caCertPath: cp.CACertPath,
|
||||||
clientCertPath: cp.ClientCertPath,
|
clientCertPath: cp.ClientCertPath,
|
||||||
clientKeyPath: cp.ClientKeyPath,
|
clientKeyPath: cp.ClientKeyPath,
|
||||||
|
hostVerification: true,
|
||||||
|
tcpNoDelay: true,
|
||||||
|
retryCount: 3,
|
||||||
|
reconnectionBaseDelay: time.Second,
|
||||||
|
reconnectionMaxDelay: 60 * time.Second,
|
||||||
}
|
}
|
||||||
if cp.Port > 0 {
|
if cp.Port > 0 {
|
||||||
config.port = cp.Port
|
config.port = cp.Port
|
||||||
@@ -101,14 +115,7 @@ func applyConnectionString(config *cassandraConfig, params url.Values, raw strin
|
|||||||
config.password = password
|
config.password = password
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
config.hosts = splitHosts(parsed.Hostname())
|
config.hosts = splitHosts(parsed.Host)
|
||||||
if strings.Contains(parsed.Host, ",") {
|
|
||||||
hostPart := parsed.Host
|
|
||||||
if parsed.User != nil {
|
|
||||||
hostPart = strings.TrimPrefix(hostPart, parsed.User.String()+"@")
|
|
||||||
}
|
|
||||||
config.hosts = splitHosts(hostPart)
|
|
||||||
}
|
|
||||||
if port := parsed.Port(); port != "" {
|
if port := parsed.Port(); port != "" {
|
||||||
parsedPort, parseErr := strconv.Atoi(port)
|
parsedPort, parseErr := strconv.Atoi(port)
|
||||||
if parseErr != nil || parsedPort < 1 || parsedPort > 65535 {
|
if parseErr != nil || parsedPort < 1 || parsedPort > 65535 {
|
||||||
@@ -193,18 +200,60 @@ func applyCassandraURLParams(config *cassandraConfig, params url.Values) error {
|
|||||||
config.pageSize = size
|
config.pageSize = size
|
||||||
case "cqlversion":
|
case "cqlversion":
|
||||||
config.cqlVersion = value
|
config.cqlVersion = value
|
||||||
case "ssl":
|
case "ssl", "enablessl":
|
||||||
enabled, err := strconv.ParseBool(value)
|
enabled, err := strconv.ParseBool(value)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return fmt.Errorf("invalid ssl option: %w", err)
|
return fmt.Errorf("invalid ssl option: %w", err)
|
||||||
}
|
}
|
||||||
config.ssl = enabled
|
config.ssl = enabled
|
||||||
case "hostverification", "verifyhostname", "sslhostnameverification":
|
case "hostverification", "verifyhostname", "sslhostnameverification", "hostnameverification":
|
||||||
enabled, err := strconv.ParseBool(value)
|
enabled, err := strconv.ParseBool(value)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return fmt.Errorf("invalid host verification option: %w", err)
|
return fmt.Errorf("invalid host verification option: %w", err)
|
||||||
}
|
}
|
||||||
config.hostVerification = enabled
|
config.hostVerification = enabled
|
||||||
|
case "tcpnodelay":
|
||||||
|
enabled, err := strconv.ParseBool(value)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("invalid tcpnodelay option: %w", err)
|
||||||
|
}
|
||||||
|
config.tcpNoDelay = enabled
|
||||||
|
case "keepalive":
|
||||||
|
enabled, err := strconv.ParseBool(value)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("invalid keepalive option: %w", err)
|
||||||
|
}
|
||||||
|
config.keepAlive = enabled
|
||||||
|
case "user":
|
||||||
|
config.username = value
|
||||||
|
case "password":
|
||||||
|
config.password = value
|
||||||
|
case "debug":
|
||||||
|
enabled, err := strconv.ParseBool(value)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("invalid debug option: %w", err)
|
||||||
|
}
|
||||||
|
config.debug = enabled
|
||||||
|
case "retries":
|
||||||
|
count, err := strconv.Atoi(value)
|
||||||
|
if err != nil || count < 0 || count > 1000 {
|
||||||
|
return fmt.Errorf("retries must be between 0 and 1000")
|
||||||
|
}
|
||||||
|
config.retryCount = count
|
||||||
|
case "retry":
|
||||||
|
policy, err := normalizeRetryPolicy(value)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
config.retryPolicy = policy
|
||||||
|
case "reconnection":
|
||||||
|
policy, baseDelay, maxDelay, err := parseReconnectionPolicy(value)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
config.reconnectionPolicy = policy
|
||||||
|
config.reconnectionBaseDelay = baseDelay
|
||||||
|
config.reconnectionMaxDelay = maxDelay
|
||||||
case "disableinitialhostlookup":
|
case "disableinitialhostlookup":
|
||||||
disabled, err := strconv.ParseBool(value)
|
disabled, err := strconv.ParseBool(value)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -212,9 +261,35 @@ func applyCassandraURLParams(config *cassandraConfig, params url.Values) error {
|
|||||||
}
|
}
|
||||||
config.disableInitialHostLookup = disabled
|
config.disableInitialHostLookup = disabled
|
||||||
case "loadbalancing":
|
case "loadbalancing":
|
||||||
if value != "" && !strings.EqualFold(value, "DcInferringLoadBalancingPolicy") {
|
policy, err := normalizeLoadBalancingPolicy(value)
|
||||||
return fmt.Errorf("unsupported Cassandra loadbalancing policy: %s", value)
|
if err != nil {
|
||||||
|
return err
|
||||||
}
|
}
|
||||||
|
config.loadBalancingPolicy = policy
|
||||||
|
case "sslenginefactory":
|
||||||
|
if value != "" && !strings.EqualFold(simpleClassName(value), "DefaultSslEngineFactory") {
|
||||||
|
return fmt.Errorf("custom Cassandra sslenginefactory is not supported by the native agent: %s", value)
|
||||||
|
}
|
||||||
|
config.ssl = true
|
||||||
|
case "usekrb5":
|
||||||
|
enabled, err := strconv.ParseBool(value)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("invalid usekrb5 option: %w", err)
|
||||||
|
}
|
||||||
|
if enabled {
|
||||||
|
return fmt.Errorf("Cassandra Kerberos authentication is not supported by the native agent")
|
||||||
|
}
|
||||||
|
case "secureconnectbundle":
|
||||||
|
if value != "" {
|
||||||
|
return fmt.Errorf("Cassandra secure connect bundles are not supported by the native agent")
|
||||||
|
}
|
||||||
|
case "configfile":
|
||||||
|
if value != "" {
|
||||||
|
return fmt.Errorf("Cassandra Java driver configfile is not supported; translate it to native URL parameters")
|
||||||
|
}
|
||||||
|
case "compliancemode":
|
||||||
|
// JDBC compliance modes only alter java.sql behavior. The native DBX
|
||||||
|
// JSON-RPC contract already defines statement and transaction behavior.
|
||||||
default:
|
default:
|
||||||
return fmt.Errorf("unsupported Cassandra URL parameter: %s", rawKey)
|
return fmt.Errorf("unsupported Cassandra URL parameter: %s", rawKey)
|
||||||
}
|
}
|
||||||
@@ -231,6 +306,11 @@ func (config cassandraConfig) clusterConfig(keyspace string) (*gocql.ClusterConf
|
|||||||
cluster.WriteTimeout = config.requestTimeout
|
cluster.WriteTimeout = config.requestTimeout
|
||||||
cluster.NumConns = config.numConnections
|
cluster.NumConns = config.numConnections
|
||||||
cluster.PageSize = config.pageSize
|
cluster.PageSize = config.pageSize
|
||||||
|
cluster.Dialer = cassandraDialer{
|
||||||
|
timeout: config.connectTimeout,
|
||||||
|
keepAlive: config.keepAlive,
|
||||||
|
tcpNoDelay: config.tcpNoDelay,
|
||||||
|
}
|
||||||
cluster.DisableInitialHostLookup = config.disableInitialHostLookup
|
cluster.DisableInitialHostLookup = config.disableInitialHostLookup
|
||||||
cluster.IgnorePeerAddr = config.disableInitialHostLookup
|
cluster.IgnorePeerAddr = config.disableInitialHostLookup
|
||||||
if config.protocolVersion != 0 {
|
if config.protocolVersion != 0 {
|
||||||
@@ -264,15 +344,20 @@ func (config cassandraConfig) clusterConfig(keyspace string) (*gocql.ClusterConf
|
|||||||
EnableHostVerification: config.hostVerification,
|
EnableHostVerification: config.hostVerification,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if config.localDatacenter != "" {
|
if config.debug {
|
||||||
cluster.PoolConfig.HostSelectionPolicy = gocql.TokenAwareHostPolicy(
|
cluster.Logger = gocql.NewLogger(gocql.LogLevelDebug)
|
||||||
gocql.DCAwareRoundRobinPolicy(config.localDatacenter),
|
}
|
||||||
)
|
if err := applyRetryPolicies(cluster, config); err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if err := applyLoadBalancingPolicy(cluster, config); err != nil {
|
||||||
|
return nil, err
|
||||||
}
|
}
|
||||||
return cluster, nil
|
return cluster, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func splitHosts(raw string) []string {
|
func splitHosts(raw string) []string {
|
||||||
|
raw = strings.ReplaceAll(raw, "--", ",")
|
||||||
parts := strings.FieldsFunc(raw, func(char rune) bool { return char == ',' || char == ';' })
|
parts := strings.FieldsFunc(raw, func(char rune) bool { return char == ',' || char == ';' })
|
||||||
hosts := make([]string, 0, len(parts))
|
hosts := make([]string, 0, len(parts))
|
||||||
for _, part := range parts {
|
for _, part := range parts {
|
||||||
@@ -280,16 +365,14 @@ func splitHosts(raw string) []string {
|
|||||||
if host == "" {
|
if host == "" {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
if parsedHost, _, err := net.SplitHostPort(host); err == nil {
|
hosts = append(hosts, host)
|
||||||
host = parsedHost
|
|
||||||
}
|
|
||||||
hosts = append(hosts, strings.Trim(host, "[]"))
|
|
||||||
}
|
}
|
||||||
return hosts
|
return hosts
|
||||||
}
|
}
|
||||||
|
|
||||||
func allLoopbackHosts(hosts []string) bool {
|
func allLoopbackHosts(hosts []string) bool {
|
||||||
for _, host := range hosts {
|
for _, host := range hosts {
|
||||||
|
host = hostNameOnly(host)
|
||||||
if strings.EqualFold(host, "localhost") {
|
if strings.EqualFold(host, "localhost") {
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
@@ -301,6 +384,14 @@ func allLoopbackHosts(hosts []string) bool {
|
|||||||
return len(hosts) > 0
|
return len(hosts) > 0
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func hostNameOnly(host string) string {
|
||||||
|
host = strings.TrimSpace(host)
|
||||||
|
if parsedHost, _, err := net.SplitHostPort(host); err == nil {
|
||||||
|
return parsedHost
|
||||||
|
}
|
||||||
|
return strings.Trim(host, "[]")
|
||||||
|
}
|
||||||
|
|
||||||
func parseDurationOption(value string) (time.Duration, error) {
|
func parseDurationOption(value string) (time.Duration, error) {
|
||||||
if duration, err := time.ParseDuration(value); err == nil {
|
if duration, err := time.ParseDuration(value); err == nil {
|
||||||
return duration, nil
|
return duration, nil
|
||||||
@@ -312,6 +403,158 @@ func parseDurationOption(value string) (time.Duration, error) {
|
|||||||
return time.Duration(milliseconds) * time.Millisecond, nil
|
return time.Duration(milliseconds) * time.Millisecond, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func normalizeRetryPolicy(value string) (string, error) {
|
||||||
|
name := strings.ToLower(simpleClassName(value))
|
||||||
|
switch name {
|
||||||
|
case "", "defaultretrypolicy", "simpleretrypolicy":
|
||||||
|
return "simple", nil
|
||||||
|
case "fallthroughretrypolicy":
|
||||||
|
return "fallthrough", nil
|
||||||
|
case "downgradingconsistencyretrypolicy":
|
||||||
|
return "downgrading", nil
|
||||||
|
case "exponentialbackoffretrypolicy":
|
||||||
|
return "exponential", nil
|
||||||
|
default:
|
||||||
|
return "", fmt.Errorf("unsupported Cassandra retry policy: %s", value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func normalizeLoadBalancingPolicy(value string) (string, error) {
|
||||||
|
name := strings.ToLower(simpleClassName(value))
|
||||||
|
switch name {
|
||||||
|
case "", "dcinferringloadbalancingpolicy", "defaultloadbalancingpolicy":
|
||||||
|
return "default", nil
|
||||||
|
case "roundrobinpolicy":
|
||||||
|
return "round_robin", nil
|
||||||
|
case "dcawareroundrobinpolicy":
|
||||||
|
return "dc_aware", nil
|
||||||
|
case "tokenawarepolicy":
|
||||||
|
return "token_aware", nil
|
||||||
|
default:
|
||||||
|
return "", fmt.Errorf("unsupported Cassandra loadbalancing policy: %s", value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseReconnectionPolicy(value string) (string, time.Duration, time.Duration, error) {
|
||||||
|
trimmed := strings.TrimSpace(value)
|
||||||
|
name := simpleClassName(trimmed)
|
||||||
|
parameters := ""
|
||||||
|
if open := strings.IndexByte(name, '('); open >= 0 {
|
||||||
|
parameters = strings.TrimSuffix(name[open+1:], ")")
|
||||||
|
name = name[:open]
|
||||||
|
}
|
||||||
|
policy := strings.ToLower(strings.TrimSpace(name))
|
||||||
|
baseDelay := time.Second
|
||||||
|
maxDelay := 60 * time.Second
|
||||||
|
if parameters != "" {
|
||||||
|
parts := strings.Split(parameters, ",")
|
||||||
|
for index, part := range parts {
|
||||||
|
part = strings.TrimSpace(strings.ReplaceAll(strings.ToLower(part), "(long)", ""))
|
||||||
|
seconds, err := strconv.Atoi(part)
|
||||||
|
if err != nil || seconds < 0 {
|
||||||
|
return "", 0, 0, fmt.Errorf("invalid Cassandra reconnection policy delay: %s", part)
|
||||||
|
}
|
||||||
|
if index == 0 {
|
||||||
|
baseDelay = time.Duration(seconds) * time.Second
|
||||||
|
} else if index == 1 {
|
||||||
|
maxDelay = time.Duration(seconds) * time.Second
|
||||||
|
} else {
|
||||||
|
return "", 0, 0, fmt.Errorf("too many Cassandra reconnection policy parameters")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
switch policy {
|
||||||
|
case "", "constantreconnectionpolicy":
|
||||||
|
return "constant", baseDelay, baseDelay, nil
|
||||||
|
case "exponentialreconnectionpolicy":
|
||||||
|
return "exponential", baseDelay, maxDelay, nil
|
||||||
|
default:
|
||||||
|
return "", 0, 0, fmt.Errorf("unsupported Cassandra reconnection policy: %s", value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func simpleClassName(value string) string {
|
||||||
|
value = strings.TrimSpace(value)
|
||||||
|
prefix := value
|
||||||
|
if open := strings.IndexByte(prefix, '('); open >= 0 {
|
||||||
|
prefix = prefix[:open]
|
||||||
|
}
|
||||||
|
if dot := strings.LastIndexByte(prefix, '.'); dot >= 0 {
|
||||||
|
return value[dot+1:]
|
||||||
|
}
|
||||||
|
return value
|
||||||
|
}
|
||||||
|
|
||||||
|
func applyRetryPolicies(cluster *gocql.ClusterConfig, config cassandraConfig) error {
|
||||||
|
switch config.retryPolicy {
|
||||||
|
case "":
|
||||||
|
case "simple":
|
||||||
|
cluster.RetryPolicy = &gocql.SimpleRetryPolicy{NumRetries: config.retryCount}
|
||||||
|
case "fallthrough":
|
||||||
|
cluster.RetryPolicy = &gocql.SimpleRetryPolicy{NumRetries: 0}
|
||||||
|
case "downgrading":
|
||||||
|
cluster.RetryPolicy = &gocql.DowngradingConsistencyRetryPolicy{}
|
||||||
|
case "exponential":
|
||||||
|
cluster.RetryPolicy = &gocql.ExponentialBackoffRetryPolicy{
|
||||||
|
NumRetries: config.retryCount,
|
||||||
|
Min: config.reconnectionBaseDelay,
|
||||||
|
Max: config.reconnectionMaxDelay,
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("unsupported Cassandra retry policy: %s", config.retryPolicy)
|
||||||
|
}
|
||||||
|
if config.reconnectionPolicy != "" || config.retryCount != 3 {
|
||||||
|
switch config.reconnectionPolicy {
|
||||||
|
case "", "constant":
|
||||||
|
cluster.ReconnectionPolicy = &gocql.ConstantReconnectionPolicy{
|
||||||
|
MaxRetries: config.retryCount,
|
||||||
|
Interval: config.reconnectionBaseDelay,
|
||||||
|
}
|
||||||
|
case "exponential":
|
||||||
|
cluster.ReconnectionPolicy = &gocql.ExponentialReconnectionPolicy{
|
||||||
|
MaxRetries: config.retryCount,
|
||||||
|
InitialInterval: config.reconnectionBaseDelay,
|
||||||
|
MaxInterval: config.reconnectionMaxDelay,
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("unsupported Cassandra reconnection policy: %s", config.reconnectionPolicy)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func applyLoadBalancingPolicy(cluster *gocql.ClusterConfig, config cassandraConfig) error {
|
||||||
|
policy := config.loadBalancingPolicy
|
||||||
|
if policy == "" {
|
||||||
|
policy = "default"
|
||||||
|
}
|
||||||
|
switch policy {
|
||||||
|
case "default":
|
||||||
|
if config.localDatacenter == "" {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
cluster.PoolConfig.HostSelectionPolicy = gocql.TokenAwareHostPolicy(
|
||||||
|
gocql.DCAwareRoundRobinPolicy(config.localDatacenter),
|
||||||
|
)
|
||||||
|
case "round_robin":
|
||||||
|
cluster.PoolConfig.HostSelectionPolicy = gocql.RoundRobinHostPolicy()
|
||||||
|
case "dc_aware":
|
||||||
|
if config.localDatacenter == "" {
|
||||||
|
return fmt.Errorf("DCAwareRoundRobinPolicy requires localdatacenter")
|
||||||
|
}
|
||||||
|
cluster.PoolConfig.HostSelectionPolicy = gocql.DCAwareRoundRobinPolicy(config.localDatacenter)
|
||||||
|
case "token_aware":
|
||||||
|
fallback := gocql.RoundRobinHostPolicy()
|
||||||
|
if config.localDatacenter != "" {
|
||||||
|
fallback = gocql.DCAwareRoundRobinPolicy(config.localDatacenter)
|
||||||
|
}
|
||||||
|
cluster.PoolConfig.HostSelectionPolicy = gocql.TokenAwareHostPolicy(fallback)
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("unsupported Cassandra loadbalancing policy: %s", policy)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
func normalizeOptionName(value string) string {
|
func normalizeOptionName(value string) string {
|
||||||
return strings.NewReplacer("_", "", "-", "", ".", "").Replace(strings.ToLower(strings.TrimSpace(value)))
|
return strings.NewReplacer("_", "", "-", "", ".", "").Replace(strings.ToLower(strings.TrimSpace(value)))
|
||||||
}
|
}
|
||||||
@@ -1,8 +1,11 @@
|
|||||||
package main
|
package main
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"reflect"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
gocql "github.com/apache/cassandra-gocql-driver/v2"
|
||||||
)
|
)
|
||||||
|
|
||||||
func TestParseCassandraConfigSupportsLegacyJDBCOptions(t *testing.T) {
|
func TestParseCassandraConfigSupportsLegacyJDBCOptions(t *testing.T) {
|
||||||
@@ -40,7 +43,7 @@ func TestParseCassandraConfigAcceptsConnectionString(t *testing.T) {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
t.Fatal(err)
|
t.Fatal(err)
|
||||||
}
|
}
|
||||||
if len(config.hosts) != 1 || config.hosts[0] != "db.example.com" || config.port != 9142 {
|
if len(config.hosts) != 1 || config.hosts[0] != "db.example.com:9142" || config.port != 9142 {
|
||||||
t.Fatalf("unexpected endpoint: %#v", config)
|
t.Fatalf("unexpected endpoint: %#v", config)
|
||||||
}
|
}
|
||||||
if config.keyspace != "catalog" || config.username != "alice" || config.password != "secret" {
|
if config.keyspace != "catalog" || config.username != "alice" || config.password != "secret" {
|
||||||
@@ -51,6 +54,106 @@ func TestParseCassandraConfigAcceptsConnectionString(t *testing.T) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestParseCassandraConfigCoversMappableJDBCWrapperOptions(t *testing.T) {
|
||||||
|
config, err := parseCassandraConfig(connectParams{
|
||||||
|
ConnectionString: "jdbc:cassandra://host1--host2:9142/catalog?" +
|
||||||
|
"user=query-user&password=query-secret&enablessl=true&hostnameverification=false&" +
|
||||||
|
"tcpnodelay=false&keepalive=true&debug=true&retries=7&retry=DefaultRetryPolicy&" +
|
||||||
|
"reconnection=ExponentialReconnectionPolicy((long)2,(long)30)&" +
|
||||||
|
"loadbalancing=TokenAwarePolicy&compliancemode=Liquibase",
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(config.hosts, []string{"host1", "host2:9142"}) || config.port != 9142 {
|
||||||
|
t.Fatalf("unexpected multi-host endpoint: hosts=%#v port=%d", config.hosts, config.port)
|
||||||
|
}
|
||||||
|
if config.username != "query-user" || config.password != "query-secret" {
|
||||||
|
t.Fatalf("unexpected query credentials: %#v", config)
|
||||||
|
}
|
||||||
|
if !config.ssl || config.hostVerification || config.tcpNoDelay || !config.keepAlive || !config.debug {
|
||||||
|
t.Fatalf("unexpected transport options: %#v", config)
|
||||||
|
}
|
||||||
|
if config.retryPolicy != "simple" || config.retryCount != 7 || config.reconnectionPolicy != "exponential" {
|
||||||
|
t.Fatalf("unexpected retry options: %#v", config)
|
||||||
|
}
|
||||||
|
if config.reconnectionBaseDelay != 2*time.Second || config.reconnectionMaxDelay != 30*time.Second {
|
||||||
|
t.Fatalf("unexpected reconnection delays: %#v", config)
|
||||||
|
}
|
||||||
|
if config.loadBalancingPolicy != "token_aware" {
|
||||||
|
t.Fatalf("unexpected load-balancing option: %#v", config)
|
||||||
|
}
|
||||||
|
|
||||||
|
cluster, err := config.clusterConfig(config.keyspace)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
dialer, ok := cluster.Dialer.(cassandraDialer)
|
||||||
|
if !ok || dialer.tcpNoDelay || !dialer.keepAlive {
|
||||||
|
t.Fatalf("unexpected socket dialer: %#v", cluster.Dialer)
|
||||||
|
}
|
||||||
|
retryPolicy, ok := cluster.RetryPolicy.(*gocql.SimpleRetryPolicy)
|
||||||
|
if !ok || retryPolicy.NumRetries != 7 {
|
||||||
|
t.Fatalf("unexpected query retry policy: %#v", cluster.RetryPolicy)
|
||||||
|
}
|
||||||
|
reconnectionPolicy, ok := cluster.ReconnectionPolicy.(*gocql.ExponentialReconnectionPolicy)
|
||||||
|
if !ok || reconnectionPolicy.MaxRetries != 7 || reconnectionPolicy.InitialInterval != 2*time.Second || reconnectionPolicy.MaxInterval != 30*time.Second {
|
||||||
|
t.Fatalf("unexpected reconnection policy: %#v", cluster.ReconnectionPolicy)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseCassandraConfigUsesSecureTransportDefaults(t *testing.T) {
|
||||||
|
config, err := parseCassandraConfig(connectParams{Host: "127.0.0.1:9042", SSL: true})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if !config.hostVerification || !config.tcpNoDelay || config.keepAlive {
|
||||||
|
t.Fatalf("unexpected defaults: %#v", config)
|
||||||
|
}
|
||||||
|
if !config.disableInitialHostLookup {
|
||||||
|
t.Fatal("loopback host with explicit port must disable peer discovery")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseCassandraConfigAcceptsDefaultSSLEngineFactory(t *testing.T) {
|
||||||
|
config, err := parseCassandraConfig(connectParams{
|
||||||
|
Host: "localhost",
|
||||||
|
URLParams: "sslenginefactory=com.datastax.oss.driver.internal.core.ssl.DefaultSslEngineFactory&usekrb5=false",
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if !config.ssl {
|
||||||
|
t.Fatal("default SSL engine factory must enable TLS")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseCassandraConfigRejectsJavaOnlyJDBCOptions(t *testing.T) {
|
||||||
|
tests := []string{
|
||||||
|
"configfile=/tmp/application.conf",
|
||||||
|
"secureconnectbundle=/tmp/secure-connect.zip",
|
||||||
|
"usekrb5=true",
|
||||||
|
"sslenginefactory=example.CustomSslEngineFactory",
|
||||||
|
}
|
||||||
|
for _, urlParams := range tests {
|
||||||
|
if _, err := parseCassandraConfig(connectParams{Host: "localhost", URLParams: urlParams}); err == nil {
|
||||||
|
t.Fatalf("expected unsupported Java-only option error for %q", urlParams)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseReconnectionPolicySupportsFullyQualifiedClass(t *testing.T) {
|
||||||
|
policy, baseDelay, maxDelay, err := parseReconnectionPolicy(
|
||||||
|
"com.datastax.oss.driver.internal.core.connection.ExponentialReconnectionPolicy((long)1,(long)8)",
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if policy != "exponential" || baseDelay != time.Second || maxDelay != 8*time.Second {
|
||||||
|
t.Fatalf("unexpected policy: %s %s %s", policy, baseDelay, maxDelay)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
func TestParseCassandraConfigRejectsUnsupportedLoadBalancingClass(t *testing.T) {
|
func TestParseCassandraConfigRejectsUnsupportedLoadBalancingClass(t *testing.T) {
|
||||||
_, err := parseCassandraConfig(connectParams{
|
_, err := parseCassandraConfig(connectParams{
|
||||||
Host: "localhost",
|
Host: "localhost",
|
||||||
|
|||||||
@@ -0,0 +1,48 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"net"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
const cassandraKeepAlivePeriod = 30 * time.Second
|
||||||
|
|
||||||
|
type cassandraDialer struct {
|
||||||
|
timeout time.Duration
|
||||||
|
keepAlive bool
|
||||||
|
tcpNoDelay bool
|
||||||
|
}
|
||||||
|
|
||||||
|
func (dialer cassandraDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
|
||||||
|
keepAlivePeriod := time.Duration(-1)
|
||||||
|
if dialer.keepAlive {
|
||||||
|
keepAlivePeriod = cassandraKeepAlivePeriod
|
||||||
|
}
|
||||||
|
connection, err := (&net.Dialer{
|
||||||
|
Timeout: dialer.timeout,
|
||||||
|
KeepAlive: keepAlivePeriod,
|
||||||
|
}).DialContext(ctx, network, address)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
tcpConnection, ok := connection.(*net.TCPConn)
|
||||||
|
if !ok {
|
||||||
|
return connection, nil
|
||||||
|
}
|
||||||
|
if err := tcpConnection.SetNoDelay(dialer.tcpNoDelay); err != nil {
|
||||||
|
connection.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if err := tcpConnection.SetKeepAlive(dialer.keepAlive); err != nil {
|
||||||
|
connection.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if dialer.keepAlive {
|
||||||
|
if err := tcpConnection.SetKeepAlivePeriod(cassandraKeepAlivePeriod); err != nil {
|
||||||
|
connection.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return connection, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,206 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestCassandraIntegration(t *testing.T) {
|
||||||
|
host := strings.TrimSpace(os.Getenv("CASSANDRA_TEST_HOST"))
|
||||||
|
if host == "" {
|
||||||
|
t.Skip("Cassandra integration environment is not configured")
|
||||||
|
}
|
||||||
|
port := 9042
|
||||||
|
if rawPort := strings.TrimSpace(os.Getenv("CASSANDRA_TEST_PORT")); rawPort != "" {
|
||||||
|
parsedPort, err := strconv.Atoi(rawPort)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
port = parsedPort
|
||||||
|
}
|
||||||
|
ssl, err := strconv.ParseBool(envDefault("CASSANDRA_TEST_SSL", "false"))
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
connection := connectParams{
|
||||||
|
Host: host,
|
||||||
|
Port: port,
|
||||||
|
Username: os.Getenv("CASSANDRA_TEST_USERNAME"),
|
||||||
|
Password: os.Getenv("CASSANDRA_TEST_PASSWORD"),
|
||||||
|
URLParams: os.Getenv("CASSANDRA_TEST_URL_PARAMS"),
|
||||||
|
SSL: ssl,
|
||||||
|
CACertPath: os.Getenv("CASSANDRA_TEST_CA_CERT_PATH"),
|
||||||
|
ClientCertPath: os.Getenv("CASSANDRA_TEST_CLIENT_CERT_PATH"),
|
||||||
|
ClientKeyPath: os.Getenv("CASSANDRA_TEST_CLIENT_KEY_PATH"),
|
||||||
|
}
|
||||||
|
runtime, err := newConnectionRuntime(connection)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer runtime.close()
|
||||||
|
server := newServer(runtime, connection)
|
||||||
|
if err := server.validateConnection(); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
suffix := strconv.FormatInt(time.Now().UnixNano(), 36)
|
||||||
|
keyspace := "dbx_native_it_" + suffix
|
||||||
|
table := "all_types"
|
||||||
|
pagedTable := "paged_rows"
|
||||||
|
mustCQL(t, server, "CREATE KEYSPACE "+quoteCQLIdentifier(keyspace)+" WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}", "")
|
||||||
|
t.Cleanup(func() {
|
||||||
|
_, _ = server.executeQuery(queryOptions{SQL: "DROP KEYSPACE IF EXISTS " + quoteCQLIdentifier(keyspace)})
|
||||||
|
})
|
||||||
|
mustCQL(t, server, "CREATE TABLE "+qualifiedCQLName(keyspace, table)+" ("+
|
||||||
|
"id int PRIMARY KEY, txt text, flag boolean, amount decimal, payload blob, created timestamp, address inet, "+
|
||||||
|
"tags set<text>, items list<int>, attrs map<text, int>, pair frozen<tuple<int, text>>)", keyspace)
|
||||||
|
mustCQL(t, server, "CREATE INDEX "+quoteCQLIdentifier(table+"_txt_idx")+" ON "+qualifiedCQLName(keyspace, table)+" (txt)", keyspace)
|
||||||
|
mustCQL(t, server, "INSERT INTO "+qualifiedCQLName(keyspace, table)+" "+
|
||||||
|
"(id, txt, flag, amount, payload, created, address, tags, items, attrs, pair) VALUES "+
|
||||||
|
"(1, 'hello', true, 12.34, 0x00ff, '2026-08-03T00:00:00Z', '127.0.0.1', {'a', 'b'}, [1, 2], {'a': 1}, (7, 'seven'))", keyspace)
|
||||||
|
mustCQL(t, server, "CREATE TABLE "+qualifiedCQLName(keyspace, pagedTable)+" (id int PRIMARY KEY, txt text)", keyspace)
|
||||||
|
|
||||||
|
for start := 0; start < 250; start += 50 {
|
||||||
|
statements := make([]string, 0, 50)
|
||||||
|
for id := start; id < start+50; id++ {
|
||||||
|
statements = append(statements, fmt.Sprintf("INSERT INTO %s (id, txt) VALUES (%d, 'row-%d')", qualifiedCQLName(keyspace, pagedTable), id, id))
|
||||||
|
}
|
||||||
|
mustStatements(t, server, keyspace, statements, false)
|
||||||
|
}
|
||||||
|
mustStatements(t, server, keyspace, []string{
|
||||||
|
"INSERT INTO " + qualifiedCQLName(keyspace, pagedTable) + " (id, txt) VALUES (1001, 'unlogged')",
|
||||||
|
}, false)
|
||||||
|
mustStatements(t, server, keyspace, []string{
|
||||||
|
"INSERT INTO " + qualifiedCQLName(keyspace, pagedTable) + " (id, txt) VALUES (1002, 'logged')",
|
||||||
|
}, true)
|
||||||
|
|
||||||
|
connectionInfo, err := server.connectionInfo()
|
||||||
|
if err != nil || strings.TrimSpace(fmt.Sprint(connectionInfo["database_version"])) == "" {
|
||||||
|
t.Fatalf("connection info failed: info=%v err=%v", connectionInfo, err)
|
||||||
|
}
|
||||||
|
databases, err := server.listDatabases()
|
||||||
|
if err != nil || !containsDatabase(databases, keyspace) {
|
||||||
|
t.Fatalf("keyspace metadata missing: databases=%v err=%v", databases, err)
|
||||||
|
}
|
||||||
|
tables, err := server.listTables(keyspace, metadataListConstraints{})
|
||||||
|
if err != nil || !containsTable(tables, table) || !containsTable(tables, pagedTable) {
|
||||||
|
t.Fatalf("table metadata missing: tables=%v err=%v", tables, err)
|
||||||
|
}
|
||||||
|
columns, err := server.getColumns(keyspace, table)
|
||||||
|
if err != nil || len(columns) != 11 || !containsPrimaryKeyColumn(columns, "id") {
|
||||||
|
t.Fatalf("column metadata mismatch: columns=%v err=%v", columns, err)
|
||||||
|
}
|
||||||
|
indexes, err := server.listIndexes(keyspace, table)
|
||||||
|
if err != nil || !containsIndex(indexes, table+"_txt_idx") {
|
||||||
|
t.Fatalf("index metadata missing: indexes=%v err=%v", indexes, err)
|
||||||
|
}
|
||||||
|
ddl, err := server.getTableDDL(keyspace, table)
|
||||||
|
if err != nil || !strings.Contains(ddl, "tuple<int, text>") || !strings.Contains(ddl, "PRIMARY KEY") {
|
||||||
|
t.Fatalf("table DDL mismatch: ddl=%q err=%v", ddl, err)
|
||||||
|
}
|
||||||
|
result, err := server.executeQuery(queryOptions{
|
||||||
|
SQL: "SELECT * FROM " + qualifiedCQLName(keyspace, table) + " WHERE id = 1",
|
||||||
|
Schema: keyspace,
|
||||||
|
})
|
||||||
|
if err != nil || len(result.Rows) != 1 || len(result.Rows[0]) != len(result.Columns) {
|
||||||
|
t.Fatalf("all-types query failed: result=%v err=%v", result, err)
|
||||||
|
}
|
||||||
|
for _, value := range result.Rows[0] {
|
||||||
|
if value != nil {
|
||||||
|
if _, ok := value.(string); !ok {
|
||||||
|
t.Fatalf("legacy result contract requires strings, got %T (%v)", value, value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
page, err := server.executeQueryPage(queryOptions{
|
||||||
|
SQL: "SELECT id, txt FROM " + qualifiedCQLName(keyspace, pagedTable),
|
||||||
|
Schema: keyspace,
|
||||||
|
MaxRows: 250,
|
||||||
|
}, 100)
|
||||||
|
if err != nil || len(page.Rows) != 100 || !page.HasMore || page.SessionID == nil {
|
||||||
|
t.Fatalf("first page mismatch: page=%v err=%v", page, err)
|
||||||
|
}
|
||||||
|
totalRows := len(page.Rows)
|
||||||
|
for page.HasMore {
|
||||||
|
page, err = server.fetchQueryPage(*page.SessionID, 100)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
totalRows += len(page.Rows)
|
||||||
|
}
|
||||||
|
if totalRows != 250 {
|
||||||
|
t.Fatalf("unexpected paged row count: %d", totalRows)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func envDefault(name, fallback string) string {
|
||||||
|
if value := strings.TrimSpace(os.Getenv(name)); value != "" {
|
||||||
|
return value
|
||||||
|
}
|
||||||
|
return fallback
|
||||||
|
}
|
||||||
|
|
||||||
|
func qualifiedCQLName(keyspace, object string) string {
|
||||||
|
return quoteCQLIdentifier(keyspace) + "." + quoteCQLIdentifier(object)
|
||||||
|
}
|
||||||
|
|
||||||
|
func mustCQL(t *testing.T, server *server, sql, keyspace string) {
|
||||||
|
t.Helper()
|
||||||
|
if _, err := server.executeQuery(queryOptions{SQL: sql, Schema: keyspace}); err != nil {
|
||||||
|
t.Fatalf("execute %q: %v", sql, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func mustStatements(t *testing.T, server *server, keyspace string, statements []string, transactional bool) {
|
||||||
|
t.Helper()
|
||||||
|
rawStatements, _ := json.Marshal(statements)
|
||||||
|
rawSchema, _ := json.Marshal(keyspace)
|
||||||
|
if _, err := server.executeStatements(map[string]json.RawMessage{
|
||||||
|
"schema": rawSchema,
|
||||||
|
"statements": rawStatements,
|
||||||
|
}, transactional); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func containsDatabase(databases []databaseInfo, name string) bool {
|
||||||
|
for _, database := range databases {
|
||||||
|
if database.Name == name {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func containsTable(tables []tableInfo, name string) bool {
|
||||||
|
for _, table := range tables {
|
||||||
|
if table.Name == name {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func containsIndex(indexes []indexInfo, name string) bool {
|
||||||
|
for _, index := range indexes {
|
||||||
|
if index.Name == name {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func containsPrimaryKeyColumn(columns []columnInfo, name string) bool {
|
||||||
|
for _, column := range columns {
|
||||||
|
if column.Name == name && column.IsPrimaryKey {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
@@ -48,3 +48,20 @@ func TestTrimStatementSQL(t *testing.T) {
|
|||||||
t.Fatalf("unexpected trimmed SQL: %q", got)
|
t.Fatalf("unexpected trimmed SQL: %q", got)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestIsSchemaChangingCQL(t *testing.T) {
|
||||||
|
for _, sql := range []string{
|
||||||
|
"CREATE TABLE app.events (id int PRIMARY KEY)",
|
||||||
|
" alter keyspace app with replication = {'class': 'SimpleStrategy'} ",
|
||||||
|
"DROP INDEX app.events_idx;",
|
||||||
|
} {
|
||||||
|
if !isSchemaChangingCQL(sql) {
|
||||||
|
t.Fatalf("expected schema-changing CQL: %q", sql)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for _, sql := range []string{"SELECT * FROM app.events", "INSERT INTO app.events (id) VALUES (1)", "TRUNCATE app.events"} {
|
||||||
|
if isSchemaChangingCQL(sql) {
|
||||||
|
t.Fatalf("unexpected schema-changing CQL: %q", sql)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -35,6 +35,9 @@ func (s *server) executeQuery(options queryOptions) (queryResult, error) {
|
|||||||
}
|
}
|
||||||
if len(columns) == 0 {
|
if len(columns) == 0 {
|
||||||
err := iter.Close()
|
err := iter.Close()
|
||||||
|
if err == nil && isSchemaChangingCQL(options.SQL) {
|
||||||
|
s.runtime.invalidateMetadataSession()
|
||||||
|
}
|
||||||
result.ExecutionTimeMS = time.Since(start).Milliseconds()
|
result.ExecutionTimeMS = time.Since(start).Milliseconds()
|
||||||
return result, err
|
return result, err
|
||||||
}
|
}
|
||||||
@@ -327,3 +330,16 @@ func trimStatementSQL(sql string) string {
|
|||||||
}
|
}
|
||||||
return trimmed
|
return trimmed
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func isSchemaChangingCQL(sql string) bool {
|
||||||
|
fields := strings.Fields(trimStatementSQL(sql))
|
||||||
|
if len(fields) == 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
switch strings.ToUpper(fields[0]) {
|
||||||
|
case "CREATE", "ALTER", "DROP":
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -24,13 +24,15 @@ const (
|
|||||||
var errOperationCapacity = errors.New("agent operation capacity is temporarily exhausted")
|
var errOperationCapacity = errors.New("agent operation capacity is temporarily exhausted")
|
||||||
|
|
||||||
type connectionRuntime struct {
|
type connectionRuntime struct {
|
||||||
mu sync.Mutex
|
mu sync.Mutex
|
||||||
config cassandraConfig
|
config cassandraConfig
|
||||||
sessions map[string]*gocql.Session
|
sessions map[string]*gocql.Session
|
||||||
permits chan struct{}
|
retiredSessions []*gocql.Session
|
||||||
metadataPermits chan struct{}
|
permits chan struct{}
|
||||||
references int
|
metadataPermits chan struct{}
|
||||||
closed bool
|
activeOperations int
|
||||||
|
references int
|
||||||
|
closed bool
|
||||||
}
|
}
|
||||||
|
|
||||||
func newConnectionRuntime(cp connectParams) (*connectionRuntime, error) {
|
func newConnectionRuntime(cp connectParams) (*connectionRuntime, error) {
|
||||||
@@ -69,6 +71,23 @@ func (r *connectionRuntime) sessionFor(keyspace string) (*gocql.Session, error)
|
|||||||
return session, nil
|
return session, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (r *connectionRuntime) invalidateMetadataSession() {
|
||||||
|
var retiredSession *gocql.Session
|
||||||
|
r.mu.Lock()
|
||||||
|
if session := r.sessions[""]; session != nil {
|
||||||
|
delete(r.sessions, "")
|
||||||
|
if r.activeOperations == 0 {
|
||||||
|
retiredSession = session
|
||||||
|
} else {
|
||||||
|
r.retiredSessions = append(r.retiredSessions, session)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
r.mu.Unlock()
|
||||||
|
if retiredSession != nil {
|
||||||
|
retiredSession.Close()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
func (r *connectionRuntime) acquire(metadata bool) (func(), error) {
|
func (r *connectionRuntime) acquire(metadata bool) (func(), error) {
|
||||||
ctx, cancel := context.WithTimeout(context.Background(), operationPermitTimeout)
|
ctx, cancel := context.WithTimeout(context.Background(), operationPermitTimeout)
|
||||||
defer cancel()
|
defer cancel()
|
||||||
@@ -83,11 +102,25 @@ func (r *connectionRuntime) acquire(metadata bool) (func(), error) {
|
|||||||
}
|
}
|
||||||
select {
|
select {
|
||||||
case r.permits <- struct{}{}:
|
case r.permits <- struct{}{}:
|
||||||
|
r.mu.Lock()
|
||||||
|
r.activeOperations++
|
||||||
|
r.mu.Unlock()
|
||||||
return func() {
|
return func() {
|
||||||
|
var retiredSessions []*gocql.Session
|
||||||
|
r.mu.Lock()
|
||||||
|
r.activeOperations--
|
||||||
|
if r.activeOperations == 0 && len(r.retiredSessions) > 0 {
|
||||||
|
retiredSessions = r.retiredSessions
|
||||||
|
r.retiredSessions = nil
|
||||||
|
}
|
||||||
|
r.mu.Unlock()
|
||||||
<-r.permits
|
<-r.permits
|
||||||
if metadataAcquired {
|
if metadataAcquired {
|
||||||
<-r.metadataPermits
|
<-r.metadataPermits
|
||||||
}
|
}
|
||||||
|
for _, session := range retiredSessions {
|
||||||
|
session.Close()
|
||||||
|
}
|
||||||
}, nil
|
}, nil
|
||||||
case <-ctx.Done():
|
case <-ctx.Done():
|
||||||
if metadataAcquired {
|
if metadataAcquired {
|
||||||
@@ -105,11 +138,16 @@ func (r *connectionRuntime) close() {
|
|||||||
}
|
}
|
||||||
r.closed = true
|
r.closed = true
|
||||||
sessions := r.sessions
|
sessions := r.sessions
|
||||||
|
retiredSessions := r.retiredSessions
|
||||||
r.sessions = map[string]*gocql.Session{}
|
r.sessions = map[string]*gocql.Session{}
|
||||||
|
r.retiredSessions = nil
|
||||||
r.mu.Unlock()
|
r.mu.Unlock()
|
||||||
for _, session := range sessions {
|
for _, session := range sessions {
|
||||||
session.Close()
|
session.Close()
|
||||||
}
|
}
|
||||||
|
for _, session := range retiredSessions {
|
||||||
|
session.Close()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (r *runtimeServer) acquireRuntime(cp connectParams) (*connectionRuntime, string, error) {
|
func (r *runtimeServer) acquireRuntime(cp connectParams) (*connectionRuntime, string, error) {
|
||||||
|
|||||||
@@ -0,0 +1,60 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
gocql "github.com/apache/cassandra-gocql-driver/v2"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestInvalidateMetadataSessionDefersCloseUntilOperationsFinish(t *testing.T) {
|
||||||
|
runtime := &connectionRuntime{
|
||||||
|
sessions: map[string]*gocql.Session{"": {}},
|
||||||
|
permits: make(chan struct{}, 2),
|
||||||
|
metadataPermits: make(chan struct{}, 1),
|
||||||
|
}
|
||||||
|
|
||||||
|
releaseFirst, err := runtime.acquire(false)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
releaseSecond, err := runtime.acquire(false)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
metadataSession := runtime.sessions[""]
|
||||||
|
|
||||||
|
runtime.invalidateMetadataSession()
|
||||||
|
if metadataSession.Closed() {
|
||||||
|
t.Fatal("metadata session closed while operations were active")
|
||||||
|
}
|
||||||
|
if len(runtime.retiredSessions) != 1 {
|
||||||
|
t.Fatalf("unexpected retired session count: %d", len(runtime.retiredSessions))
|
||||||
|
}
|
||||||
|
|
||||||
|
releaseFirst()
|
||||||
|
if metadataSession.Closed() {
|
||||||
|
t.Fatal("metadata session closed before the final operation completed")
|
||||||
|
}
|
||||||
|
|
||||||
|
releaseSecond()
|
||||||
|
if !metadataSession.Closed() {
|
||||||
|
t.Fatal("metadata session was not closed after the final operation completed")
|
||||||
|
}
|
||||||
|
if len(runtime.retiredSessions) != 0 {
|
||||||
|
t.Fatalf("retired sessions were not cleared: %d", len(runtime.retiredSessions))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestInvalidateMetadataSessionClosesImmediatelyWithoutOperations(t *testing.T) {
|
||||||
|
metadataSession := &gocql.Session{}
|
||||||
|
runtime := &connectionRuntime{sessions: map[string]*gocql.Session{"": metadataSession}}
|
||||||
|
|
||||||
|
runtime.invalidateMetadataSession()
|
||||||
|
|
||||||
|
if !metadataSession.Closed() {
|
||||||
|
t.Fatal("idle metadata session was not closed immediately")
|
||||||
|
}
|
||||||
|
if _, exists := runtime.sessions[""]; exists {
|
||||||
|
t.Fatal("invalidated metadata session remains cached")
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
dependencies {
|
|
||||||
implementation fileTree(dir: 'libs', include: ['*.jar'])
|
|
||||||
implementation 'com.ing.data:cassandra-jdbc-wrapper:4.12.0'
|
|
||||||
}
|
|
||||||
|
|
||||||
tasks.named('shadowJar') {
|
|
||||||
manifest {
|
|
||||||
attributes('Agent-Label': 'Apache Cassandra', 'Main-Class': 'com.dbx.agent.cassandra.CassandraAgent')
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,211 +0,0 @@
|
|||||||
package com.dbx.agent.cassandra;
|
|
||||||
|
|
||||||
import com.dbx.agent.AbstractJdbcAgent;
|
|
||||||
import com.dbx.agent.ColumnInfo;
|
|
||||||
import com.dbx.agent.ConnectParams;
|
|
||||||
import com.dbx.agent.DatabaseInfo;
|
|
||||||
import com.dbx.agent.ForeignKeyInfo;
|
|
||||||
import com.dbx.agent.IndexInfo;
|
|
||||||
import com.dbx.agent.JdbcIdentifiers;
|
|
||||||
import com.dbx.agent.MultiSessionJsonRpcServer;
|
|
||||||
import com.dbx.agent.TableInfo;
|
|
||||||
import com.dbx.agent.TriggerInfo;
|
|
||||||
import java.sql.PreparedStatement;
|
|
||||||
import java.sql.ResultSet;
|
|
||||||
import java.util.ArrayList;
|
|
||||||
import java.util.Collections;
|
|
||||||
import java.util.Comparator;
|
|
||||||
import java.util.List;
|
|
||||||
import java.util.regex.Matcher;
|
|
||||||
import java.util.regex.Pattern;
|
|
||||||
|
|
||||||
public final class CassandraAgent extends AbstractJdbcAgent {
|
|
||||||
private static final String DC_INFERRING_LOAD_BALANCING = "loadbalancing=DcInferringLoadBalancingPolicy";
|
|
||||||
private static final Pattern TARGET_PATTERN = Pattern.compile("target[\"']?\\s*[:=]\\s*[\"']?([\\w]+)");
|
|
||||||
|
|
||||||
@Override
|
|
||||||
protected String driverClass() {
|
|
||||||
return "com.ing.data.cassandra.jdbc.CassandraDriver";
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
protected String buildJdbcUrl(ConnectParams params) {
|
|
||||||
return buildUrl(params);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public String setSchemaSQL(String schema) {
|
|
||||||
return "USE " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<DatabaseInfo> listDatabases() {
|
|
||||||
return unchecked(() -> {
|
|
||||||
List<DatabaseInfo> result = new ArrayList<>();
|
|
||||||
String sql = "SELECT keyspace_name FROM system_schema.keyspaces";
|
|
||||||
try (java.sql.Statement stmt = requireConnected().createStatement();
|
|
||||||
ResultSet rs = stmt.executeQuery(sql)) {
|
|
||||||
while (rs.next()) {
|
|
||||||
result.add(new DatabaseInfo(rs.getString(1)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result.sort(Comparator.comparing(DatabaseInfo::getName));
|
|
||||||
return result;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<String> listSchemas() {
|
|
||||||
List<String> result = new ArrayList<>();
|
|
||||||
for (DatabaseInfo database : listDatabases()) {
|
|
||||||
result.add(database.getName());
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<TableInfo> listTables(String schema) {
|
|
||||||
return unchecked(() -> {
|
|
||||||
List<TableInfo> result = new ArrayList<>();
|
|
||||||
String sql = "SELECT table_name FROM system_schema.tables WHERE keyspace_name = ?";
|
|
||||||
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
|
|
||||||
stmt.setString(1, schema);
|
|
||||||
try (ResultSet rs = stmt.executeQuery()) {
|
|
||||||
while (rs.next()) {
|
|
||||||
result.add(new TableInfo(rs.getString(1), "TABLE", null));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result.sort(Comparator.comparing(TableInfo::getName));
|
|
||||||
return result;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<ColumnInfo> getColumns(String schema, String table) {
|
|
||||||
return unchecked(() -> {
|
|
||||||
List<ColumnInfo> result = new ArrayList<>();
|
|
||||||
String sql = "SELECT column_name, type, kind FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ?";
|
|
||||||
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
|
|
||||||
stmt.setString(1, schema);
|
|
||||||
stmt.setString(2, table);
|
|
||||||
try (ResultSet rs = stmt.executeQuery()) {
|
|
||||||
while (rs.next()) {
|
|
||||||
String kind = coalesce(rs.getString("kind"));
|
|
||||||
boolean isPrimaryKey = "partition_key".equals(kind) || "clustering".equals(kind);
|
|
||||||
result.add(new ColumnInfo(
|
|
||||||
rs.getString("column_name"),
|
|
||||||
coalesce(rs.getString("type"), "unknown"),
|
|
||||||
!isPrimaryKey,
|
|
||||||
null,
|
|
||||||
isPrimaryKey,
|
|
||||||
kind.trim().isEmpty() ? null : kind,
|
|
||||||
null,
|
|
||||||
null,
|
|
||||||
null,
|
|
||||||
null
|
|
||||||
));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<IndexInfo> listIndexes(String schema, String table) {
|
|
||||||
return unchecked(() -> {
|
|
||||||
List<IndexInfo> result = new ArrayList<>();
|
|
||||||
String sql = "SELECT index_name, options FROM system_schema.indexes WHERE keyspace_name = ? AND table_name = ?";
|
|
||||||
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
|
|
||||||
stmt.setString(1, schema);
|
|
||||||
stmt.setString(2, table);
|
|
||||||
try (ResultSet rs = stmt.executeQuery()) {
|
|
||||||
while (rs.next()) {
|
|
||||||
String indexName = coalesce(rs.getString("index_name"));
|
|
||||||
String options = coalesce(rs.getString("options"));
|
|
||||||
result.add(new IndexInfo(
|
|
||||||
indexName,
|
|
||||||
targetColumns(options),
|
|
||||||
false,
|
|
||||||
false,
|
|
||||||
null,
|
|
||||||
null,
|
|
||||||
null,
|
|
||||||
null
|
|
||||||
));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result.sort(Comparator.comparing(IndexInfo::getName));
|
|
||||||
return result;
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
|
|
||||||
return Collections.emptyList();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public List<TriggerInfo> listTriggers(String schema, String table) {
|
|
||||||
return Collections.emptyList();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
protected Object resultValue(ResultSet rs, int index, int sqlType) {
|
|
||||||
return unchecked(() -> {
|
|
||||||
Object value = rs.getObject(index);
|
|
||||||
return rs.wasNull() ? null : value == null ? null : value.toString();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
static String buildUrl(ConnectParams params) {
|
|
||||||
String baseUrl = "jdbc:cassandra://" + params.getHost() + ":" + params.getPort();
|
|
||||||
String keyspace = coalesce(params.getDatabase()).trim();
|
|
||||||
// Cassandra rejects an empty keyspace path; omit it so DBX can connect first and list keyspaces.
|
|
||||||
String url = keyspace.isEmpty() ? baseUrl : baseUrl + "/" + keyspace;
|
|
||||||
String extraParams = coalesce(params.getUrl_params()).trim();
|
|
||||||
while (extraParams.startsWith("?") || extraParams.startsWith("&")) {
|
|
||||||
extraParams = extraParams.substring(1);
|
|
||||||
}
|
|
||||||
if (!hasDatacenterOrLoadBalancingParameter(extraParams)) {
|
|
||||||
extraParams = extraParams.isEmpty()
|
|
||||||
? DC_INFERRING_LOAD_BALANCING
|
|
||||||
: extraParams + (extraParams.endsWith("&") ? "" : "&") + DC_INFERRING_LOAD_BALANCING;
|
|
||||||
}
|
|
||||||
return extraParams.isEmpty() ? url : url + "?" + extraParams;
|
|
||||||
}
|
|
||||||
|
|
||||||
private static boolean hasDatacenterOrLoadBalancingParameter(String urlParams) {
|
|
||||||
for (String param : urlParams.split("&")) {
|
|
||||||
int valueSeparator = param.indexOf('=');
|
|
||||||
String paramName = valueSeparator < 0 ? param : param.substring(0, valueSeparator);
|
|
||||||
paramName = paramName.trim();
|
|
||||||
if (paramName.equals("localdatacenter") || paramName.equals("loadbalancing")) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
private static List<String> targetColumns(String options) {
|
|
||||||
Matcher matcher = TARGET_PATTERN.matcher(options);
|
|
||||||
if (!matcher.find()) {
|
|
||||||
return Collections.emptyList();
|
|
||||||
}
|
|
||||||
return Collections.singletonList(matcher.group(1));
|
|
||||||
}
|
|
||||||
|
|
||||||
private static String coalesce(String value) {
|
|
||||||
return value == null ? "" : value;
|
|
||||||
}
|
|
||||||
|
|
||||||
private static String coalesce(String value, String fallback) {
|
|
||||||
return value == null ? fallback : value;
|
|
||||||
}
|
|
||||||
|
|
||||||
public static void main(String[] args) {
|
|
||||||
new MultiSessionJsonRpcServer(CassandraAgent::new).run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
-94
@@ -1,94 +0,0 @@
|
|||||||
package com.dbx.agent.cassandra;
|
|
||||||
|
|
||||||
import com.dbx.agent.ConnectParams;
|
|
||||||
import com.dbx.agent.DatabaseAgent;
|
|
||||||
import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
|
|
||||||
import org.junit.jupiter.api.Test;
|
|
||||||
|
|
||||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
||||||
|
|
||||||
class CassandraAgentTest extends JdbcFakeExecutionBehaviorTest {
|
|
||||||
@Override
|
|
||||||
protected DatabaseAgent createAgent() {
|
|
||||||
return new CassandraAgent();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
protected String resultSetSql() {
|
|
||||||
return "LIST ROLES";
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void buildsServerUrlWhenKeyspaceIsEmpty() {
|
|
||||||
ConnectParams params = new ConnectParams("127.0.0.1", 9042, "", "cassandra", "cassandra", "", "", false);
|
|
||||||
|
|
||||||
assertEquals(
|
|
||||||
"jdbc:cassandra://127.0.0.1:9042?loadbalancing=DcInferringLoadBalancingPolicy",
|
|
||||||
CassandraAgent.buildUrl(params)
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void buildsKeyspaceUrlWhenKeyspaceIsSet() {
|
|
||||||
ConnectParams params = new ConnectParams("127.0.0.1", 9042, "app_keyspace", "cassandra", "cassandra", "", "", false);
|
|
||||||
|
|
||||||
assertEquals(
|
|
||||||
"jdbc:cassandra://127.0.0.1:9042/app_keyspace?loadbalancing=DcInferringLoadBalancingPolicy",
|
|
||||||
CassandraAgent.buildUrl(params)
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void appendsUrlParamsForMultiDcLocalDatacenter() {
|
|
||||||
ConnectParams params = new ConnectParams(
|
|
||||||
"127.0.0.1", 9042, "app_keyspace", "cassandra", "cassandra", "localdatacenter=dc1", "", false
|
|
||||||
);
|
|
||||||
|
|
||||||
assertEquals("jdbc:cassandra://127.0.0.1:9042/app_keyspace?localdatacenter=dc1", CassandraAgent.buildUrl(params));
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void stripsLeadingQuestionMarkFromUrlParams() {
|
|
||||||
ConnectParams params = new ConnectParams(
|
|
||||||
"127.0.0.1", 9042, "", "cassandra", "cassandra", "?localdatacenter=dc1", "", false
|
|
||||||
);
|
|
||||||
|
|
||||||
assertEquals("jdbc:cassandra://127.0.0.1:9042?localdatacenter=dc1", CassandraAgent.buildUrl(params));
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void appendsInferringPolicyAfterOtherUrlParams() {
|
|
||||||
ConnectParams params = new ConnectParams(
|
|
||||||
"127.0.0.1", 9042, "", "cassandra", "cassandra", "requesttimeout=10000", "", false
|
|
||||||
);
|
|
||||||
|
|
||||||
assertEquals(
|
|
||||||
"jdbc:cassandra://127.0.0.1:9042?requesttimeout=10000&loadbalancing=DcInferringLoadBalancingPolicy",
|
|
||||||
CassandraAgent.buildUrl(params)
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void appendsInferringPolicyAfterTrailingSeparator() {
|
|
||||||
ConnectParams params = new ConnectParams(
|
|
||||||
"127.0.0.1", 9042, "", "cassandra", "cassandra", "requesttimeout=10000&", "", false
|
|
||||||
);
|
|
||||||
|
|
||||||
assertEquals(
|
|
||||||
"jdbc:cassandra://127.0.0.1:9042?requesttimeout=10000&loadbalancing=DcInferringLoadBalancingPolicy",
|
|
||||||
CassandraAgent.buildUrl(params)
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
void preservesCustomLoadBalancingPolicy() {
|
|
||||||
ConnectParams params = new ConnectParams(
|
|
||||||
"127.0.0.1", 9042, "", "cassandra", "cassandra", "loadbalancing=CustomPolicy", "", false
|
|
||||||
);
|
|
||||||
|
|
||||||
assertEquals(
|
|
||||||
"jdbc:cassandra://127.0.0.1:9042?loadbalancing=CustomPolicy",
|
|
||||||
CassandraAgent.buildUrl(params)
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -5,7 +5,7 @@ def driverModules = [
|
|||||||
'access', 'dameng', 'goldendb', 'databend', 'databricks', 'saphana',
|
'access', 'dameng', 'goldendb', 'databend', 'databricks', 'saphana',
|
||||||
'teradata', 'vertica', 'firebird', 'exasol', 'oceanbase-oracle', 'gbase8a', 'gbase8s',
|
'teradata', 'vertica', 'firebird', 'exasol', 'oceanbase-oracle', 'gbase8a', 'gbase8s',
|
||||||
'bigquery', 'kylin', 'sundb', 'h2', 'h2-legacy', 'snowflake', 'trino', 'hive', 'spark',
|
'bigquery', 'kylin', 'sundb', 'h2', 'h2-legacy', 'snowflake', 'trino', 'hive', 'spark',
|
||||||
'db2', 'informix', 'neo4j', 'cassandra', 'mongodb', 'highgo', 'uxdb', 'tdengine', 'yashandb', 'oscar',
|
'db2', 'informix', 'neo4j', 'mongodb', 'highgo', 'uxdb', 'tdengine', 'yashandb', 'oscar',
|
||||||
'iris', 'iotdb', 'etcd', 'zookeeper', 'kafka', 'rocketmq', 'sqlserver-legacy'
|
'iris', 'iotdb', 'etcd', 'zookeeper', 'kafka', 'rocketmq', 'sqlserver-legacy'
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user