@feltdb/core 0.7.2 → 0.7.3

package/dist/create/server-source/crates/feltdb/src/bin/feltdb_node.rs

@@ -45,6 +45,7 @@
 //! shutdown            exit cleanly
 //! ```
 
+use feltdb::authority_failover::{AuthorityStore, ClaimResult, FencingToken, Heartbeat};
 use feltdb::convergence::VectorClock;
 use feltdb::distributed_transactions::{
     CausalCapacity, DistributedTransactionExecutor, ReceiveOutcome, ReplicationMessage,
@@ -176,6 +177,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut recv_specs: Vec<(String, String)> = Vec::new();
     let mut max_pending_entries: Option<usize> = None;
     let mut max_pending_bytes: Option<usize> = None;
+    let mut authority_priority: u32 = 0;
 
     let mut index = 1;
     while index < args.len() {
@@ -225,6 +227,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         .map_err(|e| format!("--max-pending-bytes: {e}"))?,
                 );
             }
+            // Static priority for authority election. Higher priority nodes are
+            // preferred during failover when multiple candidates have equal state.
+            "--authority-priority" => {
+                index += 1;
+                authority_priority = args
+                    .get(index)
+                    .ok_or("--authority-priority requires a value")?
+                    .parse::<u32>()
+                    .map_err(|e| format!("--authority-priority: {e}"))?;
+            }
             other => return Err(format!("unknown argument {other}").into()),
         }
         index += 1;
@@ -265,6 +277,23 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map_err(|e| e.to_string())?,
     ));
 
+    // Authority state tracks who holds write authority in the cluster. The store
+    // is durable and survives restarts, so a node that crashes can rejoin and
+    // recover its previous role. The cluster ID is set by the first `authority-claim`
+    // command, so it starts as the node's own ID.
+    let authority = Arc::new(Mutex::new(
+        AuthorityStore::open(
+            data_dir
+                .as_ref()
+                .map(|dir| dir.join("authority.json"))
+                .unwrap_or_else(|| PathBuf::from("authority.json")),
+            &node_id, // cluster_id defaults to node_id until set
+            &node_id,
+            authority_priority,
+        )
+        .map_err(|e| e.to_string())?,
+    ));
+
     let initial_state = StateHash::from_hex("0".repeat(64));
     let mut executor =
         DistributedTransactionExecutor::with_log(node_id.clone(), initial_state.clone(), log_path.clone())?;
@@ -1147,6 +1176,198 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 io::stdout().flush().ok();
             }
 
+            // Authority failover commands.
+            //
+            // These commands implement the distributed authority protocol that prevents
+            // split-brain and allows automatic failover when the authority node fails.
+
+            // Claim authority for this node. This generates a new fencing token that
+            // supersedes any previous authority. The claim succeeds only if no other
+            // node has a higher token and appears healthy.
+            "authority-claim" => {
+                let mut guard = authority.lock().await;
+                let result = guard.claim_authority();
+                match result {
+                    Ok(ClaimResult::Granted { token }) => {
+                        println!(
+                            "AUTHORITY_CLAIMED {}",
+                            json!({
+                                "node": node_id,
+                                "fencing_token": token.0,
+                                "role": "AUTHORITY",
+                            })
+                        );
+                    }
+                    Ok(ClaimResult::Rejected { current_authority, current_token }) => {
+                        println!(
+                            "AUTHORITY_REJECTED {}",
+                            json!({
+                                "current_authority": current_authority,
+                                "current_token": current_token.0,
+                                "reason": "another authority is still active",
+                            })
+                        );
+                    }
+                    Ok(ClaimResult::Fenced { token }) => {
+                        println!(
+                            "AUTHORITY_FENCED {}",
+                            json!({
+                                "node": node_id,
+                                "fencing_token": token.0,
+                                "reason": "this node is fenced",
+                            })
+                        );
+                    }
+                    Err(e) => {
+                        println!("ERROR {}", json!({ "reason": e.to_string() }));
+                    }
+                }
+                io::stdout().flush().ok();
+            }
+
+            // Accept a new authority announced by another node.
+            // Format: authority-accept NODE_ID TOKEN
+            "authority-accept" => {
+                let mut parts = argument.split_whitespace();
+                let authority_node = parts.next().unwrap_or_default().to_string();
+                let token_value: u64 = parts
+                    .next()
+                    .unwrap_or("0")
+                    .parse()
+                    .unwrap_or(0);
+                let token = FencingToken(token_value);
+
+                let mut guard = authority.lock().await;
+                let result = guard.accept_authority(&authority_node, token);
+                match result {
+                    Ok(()) => {
+                        let state = guard.state();
+                        println!(
+                            "AUTHORITY_ACCEPTED {}",
+                            json!({
+                                "authority_node": authority_node,
+                                "fencing_token": token.0,
+                                "local_role": format!("{:?}", state.local_role),
+                            })
+                        );
+                    }
+                    Err(e) => {
+                        println!("ERROR {}", json!({ "reason": e.to_string() }));
+                    }
+                }
+                io::stdout().flush().ok();
+            }
+
+            // Query the current authority state.
+            "authority-state" => {
+                let guard = authority.lock().await;
+                let state = guard.state();
+                let operations_applied = {
+                    let core_guard = core.lock().await;
+                    let (executor, _) = &*core_guard;
+                    executor.get_replica_state(&node_id).map(|r| r.operations_applied).unwrap_or(0)
+                };
+                println!(
+                    "AUTHORITY {}",
+                    json!({
+                        "cluster_id": state.cluster_id,
+                        "local_node": state.local_node_id,
+                        "local_role": format!("{:?}", state.local_role),
+                        "is_authority": state.is_authority(),
+                        "is_fenced": state.is_fenced(),
+                        "authority_node": state.authority_node(),
+                        "current_token": state.current_token().0,
+                        "highest_seen_token": state.highest_seen_token.0,
+                        "operations_applied": operations_applied,
+                    })
+                );
+                io::stdout().flush().ok();
+            }
+
+            // Record a heartbeat from a peer. This is used for failure detection.
+            // Format: heartbeat NODE_ID [TOKEN] [OPS_APPLIED] [IS_AUTHORITY]
+            "heartbeat" => {
+                let mut parts = argument.split_whitespace();
+                let from_node = parts.next().unwrap_or_default().to_string();
+
+                if from_node.is_empty() {
+                    println!("ERROR {}", json!({ "reason": "heartbeat requires NODE_ID" }));
+                } else {
+                    let mut guard = authority.lock().await;
+                    guard.heartbeat(&from_node);
+                    println!(
+                        "HEARTBEAT_RECORDED {}",
+                        json!({
+                            "from_node": from_node,
+                        })
+                    );
+                }
+                io::stdout().flush().ok();
+            }
+
+            // Check if the current authority has failed based on heartbeat timeout.
+            "authority-failed" => {
+                let guard = authority.lock().await;
+                let failed = guard.authority_failed();
+                let failed_nodes = guard.failed_nodes();
+                let state = guard.state();
+                println!(
+                    "AUTHORITY_CHECK {}",
+                    json!({
+                        "authority_failed": failed,
+                        "current_authority": state.authority_node(),
+                        "failed_nodes": failed_nodes,
+                    })
+                );
+                io::stdout().flush().ok();
+            }
+
+            // Step down from authority role voluntarily.
+            "authority-stepdown" => {
+                let mut guard = authority.lock().await;
+                let was_authority = guard.state().is_authority();
+                let result = guard.step_down();
+                match result {
+                    Ok(()) => {
+                        println!(
+                            "AUTHORITY_STEPDOWN {}",
+                            json!({
+                                "node": node_id,
+                                "was_authority": was_authority,
+                                "now_role": format!("{:?}", guard.state().local_role),
+                            })
+                        );
+                    }
+                    Err(e) => {
+                        println!("ERROR {}", json!({ "reason": e.to_string() }));
+                    }
+                }
+                io::stdout().flush().ok();
+            }
+
+            // Recover from fenced state after catching up.
+            "authority-recover" => {
+                let mut guard = authority.lock().await;
+                let was_fenced = guard.state().is_fenced();
+                let result = guard.recover_from_fenced();
+                match result {
+                    Ok(()) => {
+                        println!(
+                            "AUTHORITY_RECOVERED {}",
+                            json!({
+                                "node": node_id,
+                                "was_fenced": was_fenced,
+                                "now_role": format!("{:?}", guard.state().local_role),
+                            })
+                        );
+                    }
+                    Err(e) => {
+                        println!("ERROR {}", json!({ "reason": e.to_string() }));
+                    }
+                }
+                io::stdout().flush().ok();
+            }
+
             "shutdown" => {
                 should_exit.store(true, Ordering::Relaxed);
                 println!("SHUTDOWN");

package/dist/create/server-source/crates/feltdb/src/lib.rs

@@ -57,6 +57,7 @@ pub mod adversarial_transport;
 pub mod replica_membership;
 pub mod replica_acknowledgements;
 pub mod replication_manager;
+pub mod authority_failover;
 pub mod metrics;
 pub mod query_performance;
 pub mod durable_sync;

package/dist/studio/app.d.ts

@@ -1,4 +1,5 @@
 import { default as React } from 'react';
+import { ManagedPublishConfiguration } from './components/ApplicationDesigner';
 import { StateFirstDB } from '@feltdb/core';
 export interface StudioAppProps {
     db?: StateFirstDB;
@@ -8,8 +9,9 @@ export interface StudioAppProps {
     deploymentRuntime?: string;
     applicationUrl?: string;
     developmentSession?: Record<string, string>;
+    managedPublish?: ManagedPublishConfiguration;
     onConnect?: (url: string, token: string) => void;
 }
-export declare function StudioApp({ db, remoteUrl, token, namespace, deploymentRuntime, applicationUrl, developmentSession, onConnect }: StudioAppProps): React.JSX.Element;
+export declare function StudioApp({ db, remoteUrl, token, namespace, deploymentRuntime, applicationUrl, developmentSession, managedPublish, onConnect }: StudioAppProps): React.JSX.Element;
 export default StudioApp;
 //# sourceMappingURL=app.d.ts.map

package/dist/studio/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAmBnD,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,SAAc,EAAE,KAAU,EAAE,SAAqB,EAAE,iBAA6B,EAAE,cAAmB,EAAE,kBAAkB,EAAE,SAAS,EAAE,EAAE,cAAc,qBA6IrL;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAgBnD,OAA4B,EAAE,KAAK,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAGzG,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,cAAc,CAAC,EAAE,2BAA2B,CAAC;IAC7C,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,SAAc,EAAE,KAAU,EAAE,SAAqB,EAAE,iBAA6B,EAAE,cAAmB,EAAE,kBAAkB,EAAE,cAAc,EAAE,SAAS,EAAE,EAAE,cAAc,qBA6IrM;AAED,eAAe,SAAS,CAAC"}

package/dist/studio/components/ApplicationDesigner.d.ts

@@ -1,11 +1,19 @@
 import { default as React } from 'react';
 import { StateFirstDB, FlowSpec } from '@feltdb/core';
+export interface ManagedPublishConfiguration {
+    url: string;
+    namespace: string;
+    token: string;
+    environment?: string;
+    applicationId?: string;
+}
 export interface ApplicationDesignerProps {
     db?: StateFirstDB;
     namespace?: string;
     projectSpec?: FlowSpec | null;
+    managedPublish?: ManagedPublishConfiguration;
     onSpecChange?: (spec: FlowSpec) => void;
 }
-export declare function ApplicationDesigner({ db, namespace, projectSpec, onSpecChange }: ApplicationDesignerProps): React.JSX.Element;
+export declare function ApplicationDesigner({ db, namespace, projectSpec, managedPublish, onSpecChange }: ApplicationDesignerProps): React.JSX.Element;
 export default ApplicationDesigner;
 //# sourceMappingURL=ApplicationDesigner.d.ts.map

package/dist/studio/components/ApplicationDesigner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ApplicationDesigner.d.ts","sourceRoot":"","sources":["../../src/components/ApplicationDesigner.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAO3E,MAAM,WAAW,wBAAwB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE;AAE3J,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,SAAqB,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,wBAAwB,qBAoHrH;AACD,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"ApplicationDesigner.d.ts","sourceRoot":"","sources":["../../src/components/ApplicationDesigner.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAO3E,MAAM,WAAW,2BAA2B;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE;AAC5I,MAAM,WAAW,wBAAwB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,cAAc,CAAC,EAAE,2BAA2B,CAAC;IAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE;AAEzM,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,SAAqB,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,EAAE,wBAAwB,qBAoHrI;AACD,eAAe,mBAAmB,CAAC"}

package/dist/studio/components/index.js

@@ -1,4 +1,4 @@
-import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p, x as m } from "../components-C5p2TfIU.js";
+import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p, x as m } from "../components-Dxuhrv8_.js";
 import { t as h } from "../KeyManagementPanel-DZuSeWBK.js";
 import { ManagedInstancePanel as g } from "./ManagedInstancePanel.js";
 export { c as AgentExplorer, f as ApplicationDesigner, p as CapabilityExplorer, t as ConflictExplorer, a as ExecutionViewer, s as GlobalSearch, i as HealthCenter, h as KeyManagementPanel, g as ManagedInstancePanel, r as OperationsExplorer, m as OverviewDashboard, n as PeerMap, e as ProvenanceViewer, l as ReferenceExplorer, u as SettingsPanel, o as StateExplorer, d as WorkflowVisualizer };