Skip to content

armgit / xerj

Public Imported from GitHub
0

AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.

fix(es-compat): migrate _segments onto the shared alias resolver (#451 class B)

xerj-org3bf87fe9dab8
diff --git a/engine/crates/xerj-api/src/es_compat.rs b/engine/crates/xerj-api/src/es_compat.rs
index 844fea195..909142920 100644
--- a/engine/crates/xerj-api/src/es_compat.rs
+++ b/engine/crates/xerj-api/src/es_compat.rs
@@ -35771,56 +35771,65 @@ pub async fn index_segments(
Path(index): Path<String>,
) -> impl IntoResponse {
let index = strip_remote_cluster_prefix(&index);
- match state.engine.get_index(&index) {
- Ok(idx) => {
- let stats = idx.stats().await;
- let snap = idx.store_snapshot();
- let num_segments = snap.segments.len();
+ // Resolve the selector through the shared resolver (#451): an alias expands
+ // to every member (`get_index` collapsed it to `aliased.first()`, so
+ // `_segments` reported one entry under the alias name). One `indices` entry
+ // per concrete member; `_shards` counts one shard per member.
+ let (members, _filters) = match resolve_selector_with_filters(&state, &index).await {
+ Ok(t) => t,
+ Err(e) => return ApiError::new(e).into_response(),
+ };
+ let mut indices_map = serde_json::Map::new();
+ for (name, idx) in &members {
+ let stats = idx.stats().await;
+ let snap = idx.store_snapshot();
+ let num_segments = snap.segments.len();
- let mut segments_map = serde_json::Map::new();
- for (i, seg) in snap.segments.iter().enumerate() {
- segments_map.insert(
- i.to_string(),
- json!({
- "generation": seg.min_seq_no,
- "num_docs": seg.doc_count,
- "deleted_docs": 0,
- "size_in_bytes": seg.size_bytes,
- "memory_in_bytes": 0,
- "committed": true,
- "search": true,
- "version": "9.10.0",
- "compound": false,
- "merges": { "merges": [] }
- }),
- );
- }
+ let mut segments_map = serde_json::Map::new();
+ for (i, seg) in snap.segments.iter().enumerate() {
+ segments_map.insert(
+ i.to_string(),
+ json!({
+ "generation": seg.min_seq_no,
+ "num_docs": seg.doc_count,
+ "deleted_docs": 0,
+ "size_in_bytes": seg.size_bytes,
+ "memory_in_bytes": 0,
+ "committed": true,
+ "search": true,
+ "version": "9.10.0",
+ "compound": false,
+ "merges": { "merges": [] }
+ }),
+ );
+ }
- Json(json!({
- "_shards": { "total": 1, "successful": 1, "failed": 0 },
- "indices": {
- index: {
- "shards": {
- "0": [{
- "routing": {
- "state": "STARTED",
- "primary": true,
- "node": "xerj-node-1"
- },
- "num_committed_segments": num_segments,
- "num_search_segments": num_segments,
- "segments": segments_map,
- "num_docs": stats.doc_count,
- "size_in_bytes": snap.segments.iter().map(|s| s.size_bytes).sum::<u64>()
- }]
- }
- }
+ indices_map.insert(
+ name.clone(),
+ json!({
+ "shards": {
+ "0": [{
+ "routing": {
+ "state": "STARTED",
+ "primary": true,
+ "node": "xerj-node-1"
+ },
+ "num_committed_segments": num_segments,
+ "num_search_segments": num_segments,
+ "segments": segments_map,
+ "num_docs": stats.doc_count,
+ "size_in_bytes": snap.segments.iter().map(|s| s.size_bytes).sum::<u64>()
+ }]
}
- }))
- .into_response()
- }
- Err(e) => ApiError::new(xerj_common::XerjError::from(e)).into_response(),
+ }),
+ );
}
+ let n = members.len();
+ Json(json!({
+ "_shards": { "total": n, "successful": n, "failed": 0 },
+ "indices": indices_map
+ }))
+ .into_response()
}
// ─────────────────────────────────────────────────────────────────────────────
diff --git a/engine/crates/xerj-api/tests/index_segments_through_alias_lists_every_member.rs b/engine/crates/xerj-api/tests/index_segments_through_alias_lists_every_member.rs
new file mode 100644
index 000000000..fe2fcf25f
--- /dev/null
+++ b/engine/crates/xerj-api/tests/index_segments_through_alias_lists_every_member.rs
@@ -0,0 +1,101 @@
+//! Issue #451 (failure class B): `GET /{index}/_segments` resolved the path
+//! index with `Engine::get_index`, which collapses an alias to
+//! `aliased.first()`. So `_segments` over a multi-index alias returned a single
+//! `indices` entry (keyed by the alias name, the first member's segments)
+//! instead of one entry per concrete member.
+//!
+//! Migrated onto the shared `resolve_selector_with_filters` resolver (#451).
+//!
+//! Elasticsearch is referenced for wire semantics only; no ES code is
+//! reproduced here.
+
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use serde_json::{json, Value};
+use tower::ServiceExt;
+
+async fn app() -> (axum::Router, tempfile::TempDir) {
+ let dir = tempfile::tempdir().expect("tempdir");
+ let mut config = xerj_common::config::Config::default();
+ config.server.data_dir = dir.path().to_string_lossy().into_owned();
+ config.storage.wal_sync = xerj_common::config::WalSync::Async;
+ let metrics = xerj_common::metrics::Metrics::new().expect("metrics");
+ let engine = xerj_engine::Engine::new(config.clone()).expect("engine");
+ let state = xerj_api::state::AppState::new(config, engine, metrics);
+ (xerj_api::router::build_es_compat_router(state), dir)
+}
+
+async fn call(app: &axum::Router, method: &str, path: &str, body: Value) -> (StatusCode, Value) {
+ let mut req = Request::builder().method(method).uri(path);
+ let body = if body.is_null() {
+ Body::empty()
+ } else {
+ req = req.header("content-type", "application/json");
+ Body::from(body.to_string())
+ };
+ let response = app.clone().oneshot(req.body(body).unwrap()).await.unwrap();
+ let status = response.status();
+ let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
+ .await
+ .unwrap();
+ (
+ status,
+ serde_json::from_slice(&bytes).unwrap_or(Value::Null),
+ )
+}
+
+/// `_segments` over a 2-member alias must return one `indices` entry per member,
+/// keyed by the concrete member names — not one entry under the alias name.
+#[tokio::test]
+async fn index_segments_through_a_multi_index_alias_lists_every_member() {
+ let (app, _dir) = app().await;
+
+ for (member, id) in [("idx-a", "1"), ("idx-b", "2")] {
+ let (st, _) = call(
+ &app,
+ "PUT",
+ &format!("/{member}"),
+ json!({"mappings": {"properties": {"v": {"type": "keyword"}}}}),
+ )
+ .await;
+ assert_eq!(st, StatusCode::OK, "create {member}");
+ let (st, _) = call(
+ &app,
+ "PUT",
+ &format!("/{member}/_doc/{id}"),
+ json!({"v": member}),
+ )
+ .await;
+ assert_eq!(st, StatusCode::CREATED, "index doc {id} into {member}");
+ let (st, _) = call(&app, "POST", &format!("/{member}/_refresh"), Value::Null).await;
+ assert_eq!(st, StatusCode::OK, "refresh {member}");
+ }
+ let (st, _) = call(
+ &app,
+ "POST",
+ "/_aliases",
+ json!({"actions": [
+ {"add": {"index": "idx-a", "alias": "tri"}},
+ {"add": {"index": "idx-b", "alias": "tri"}}
+ ]}),
+ )
+ .await;
+ assert_eq!(st, StatusCode::OK, "create alias tri");
+
+ let (status, body) = call(&app, "GET", "/tri/_segments", Value::Null).await;
+ assert_eq!(status, StatusCode::OK, "_segments status: {body}");
+
+ let indices = body
+ .pointer("/indices")
+ .and_then(Value::as_object)
+ .cloned()
+ .unwrap_or_default();
+ let mut keys: Vec<String> = indices.keys().cloned().collect();
+ keys.sort();
+ assert_eq!(
+ keys,
+ vec!["idx-a".to_string(), "idx-b".to_string()],
+ "_segments through the alias must list an entry per concrete member, not one \
+ entry under the alias name (#451): {body}"
+ );
+}