Add local DB resource registration

crates/geth-node/Cargo.toml

@@ -15,6 +15,7 @@ geth-cas = { path = "../geth-cas" }
 geth-config = { path = "../geth-config" }
 geth-control = { path = "../geth-control" }
 geth-crypto = { path = "../geth-crypto" }
+geth-db = { path = "../geth-db" }
 geth-iroh = { path = "../geth-iroh" }
 geth-keychain = { path = "../geth-keychain" }
 geth-resource = { path = "../geth-resource" }

crates/geth-node/src/lib.rs

@@ -8,6 +8,7 @@ use geth_control::{
     StatusResponse,
 };
 use geth_crypto::AgentKey;
+use geth_db::DbResource;
 use geth_iroh::{EndpointStatus, GethIrohConfig, GethIrohEndpoint, GethRelayMode};
 use geth_keychain::{KeychainOp, KeychainOpKind};
 use geth_resource::ResourceDescriptor;
@@ -17,7 +18,7 @@ use geth_ssh_identity::{
     certificate_id, revocation_id, ssh_public_key_fingerprint,
 };
 use geth_store::{
-    Store, StoredAuthOp, StoredKeychainOp, StoredResource, StoredSshCertRequest,
+    Store, StoredAuthOp, StoredDbResource, StoredKeychainOp, StoredResource, StoredSshCertRequest,
     StoredSshCertificate, StoredSshRevocation,
 };
 use geth_types::{
@@ -46,6 +47,12 @@ pub enum NodeError {
     Io(#[from] std::io::Error),
     #[error("invalid resource kind: {0}")]
     InvalidResourceKind(String),
+    #[error("invalid db resource name: {0}")]
+    InvalidDbName(String),
+    #[error("db path does not exist or is not a file: {0}")]
+    InvalidDbPath(String),
+    #[error("db resource not found: {0}")]
+    DbNotFound(String),
     #[error("invalid ssh certificate kind: {0}")]
     InvalidSshCertKind(String),
     #[error("invalid ssh certificate request status: {0}")]
@@ -550,6 +557,41 @@ pub fn handle_request(
                 count: revocations.len(),
             })
         }
+        ControlRequest::DbAdd { name, path } => {
+            geth_db::validate_db_name(&name).map_err(|_| NodeError::InvalidDbName(name.clone()))?;
+            if !path.is_file() {
+                return Err(NodeError::InvalidDbPath(path.display().to_string()));
+            }
+            let path = std::fs::canonicalize(path)?;
+            let resource_id = format!("resource:db:{name}");
+            let db_id = format!("db:{name}");
+            let resource = StoredResource {
+                resource_id: resource_id.clone(),
+                kind: ResourceKind::Db.to_string(),
+                name: name.clone(),
+                status: "active".to_owned(),
+            };
+            store.insert_resource(&resource)?;
+            let stored = StoredDbResource {
+                db_id,
+                resource_id,
+                name,
+                path: path.display().to_string(),
+            };
+            store.insert_db_resource(&stored)?;
+            Ok(ControlResponse::DbAdded {
+                db: db_resource_from_stored(&stored)?,
+            })
+        }
+        ControlRequest::DbStatus { name } => {
+            geth_db::validate_db_name(&name).map_err(|_| NodeError::InvalidDbName(name.clone()))?;
+            let stored = store
+                .get_db_resource_by_name(&name)?
+                .ok_or_else(|| NodeError::DbNotFound(name.clone()))?;
+            Ok(ControlResponse::DbStatus {
+                db: db_resource_from_stored(&stored)?,
+            })
+        }
         ControlRequest::ModuleStub { module, command } => {
             Ok(ControlResponse::NotImplemented { module, command })
         }
@@ -568,6 +610,21 @@ fn stored_resource_to_descriptor(stored: StoredResource) -> Result<ResourceDescr
     ))
 }
 
+fn db_resource_from_stored(stored: &StoredDbResource) -> Result<DbResource, NodeError> {
+    let path = Path::new(&stored.path);
+    let metadata = path.metadata().ok();
+    Ok(DbResource {
+        id: stored.db_id.clone().into(),
+        resource: stored.resource_id.clone().into(),
+        name: stored.name.clone(),
+        path: stored.path.clone(),
+        path_exists: metadata.as_ref().is_some_and(std::fs::Metadata::is_file),
+        size_bytes: metadata.map(|metadata| metadata.len()),
+        schema_metadata: "not-inspected-until-crsqlite-integration".to_owned(),
+        sync_status: "local-only".to_owned(),
+    })
+}
+
 fn store_auth_op(store: &Store, op: &AuthOp) -> Result<(), NodeError> {
     store.insert_auth_op(&StoredAuthOp {
         op_id: op.id.to_string(),