swactor/crates/data-plane/src/control.rs

//! Reusable namespace service lifecycle and public file-registration control.

use std::path::Path;
use std::sync::Arc;
use std::time::Duration;

use swactor::actor::ActorAddress;
use swactor::runtime::Runtime;
use swactor_engine::EngineHandle;

use crate::blob::FileRegistration;
use crate::blob_transfer::BlobTransferSender;
use crate::namespace::{
    DataDirectoryActor, DirectoryClient, NamespaceError, OperationId, RetirementRetry,
};
use crate::namespace_store::SourceRecovery;
use crate::path::DataPath;
use crate::source::{BlobSourceIn, BlobSourcePublisher, FileBlobSourceActor};

/// How often the directory re-sends retirements that no source has
/// acknowledged yet. Retire frames are at-most-once; this retry bounds how
/// long a lost frame can strand a published source and its binding.
const RETIREMENT_RETRY_PERIOD: Duration = Duration::from_millis(250);

pub struct DataNamespaceService {
    directory: ActorAddress,
    control: DataPlaneControl,
}

impl DataNamespaceService {
    pub fn recover(
        runtime: Runtime,
        engine: EngineHandle,
        store_path: impl AsRef<Path>,
        source_sender: Arc<dyn BlobTransferSender>,
        source_publisher: Arc<dyn BlobSourcePublisher>,
    ) -> Result<Self, NamespaceError> {
        let recovery_runtime = runtime.clone();
        let recovery_sender = Arc::clone(&source_sender);
        let recovery_publisher = Arc::clone(&source_publisher);
        let retire_retry =
            RetirementRetry::new(engine, runtime.create_sender(), RETIREMENT_RETRY_PERIOD);
        let directory = DataDirectoryActor::recover(
            store_path,
            Some(retire_retry),
            move |recovery, expected_length| match recovery {
                SourceRecovery::File { path } => {
                    let source = FileBlobSourceActor::recover(
                        recovery_runtime.clone(),
                        Arc::clone(&recovery_sender),
                        path,
                        expected_length,
                    )?;
                    let source = recovery_runtime.spawn(source).map_err(|error| {
                        NamespaceError::SourceRecovery(format!(
                            "spawn recovered file source {}: {error}",
                            path.display()
                        ))
                    })?;
                    if let Err(error) = recovery_publisher.publish_source(source) {
                        let _ = recovery_runtime
                            .send_to(source, BlobSourceIn::Retire { reply_to: None });
                        return Err(NamespaceError::SourceRecovery(error));
                    }
                    Ok(source)
                }
                SourceRecovery::Actor { actor } => Ok(*actor),
            },
        )?;
        let directory = runtime.spawn(directory).map_err(|error| {
            NamespaceError::SourceRecovery(format!("spawn data directory: {error}"))
        })?;
        let control = DataPlaneControl {
            runtime: runtime.clone(),
            directory: DirectoryClient::new(runtime, directory),
            source_sender,
            source_publisher,
        };
        Ok(Self { directory, control })
    }

    pub fn directory(&self) -> ActorAddress {
        self.directory
    }

    pub fn control(&self) -> DataPlaneControl {
        self.control.clone()
    }
}

#[derive(Clone)]
pub struct DataPlaneControl {
    runtime: Runtime,
    directory: DirectoryClient,
    source_sender: Arc<dyn BlobTransferSender>,
    source_publisher: Arc<dyn BlobSourcePublisher>,
}

impl DataPlaneControl {
    pub async fn ensure(
        &self,
        path: DataPath,
        registration: FileRegistration,
    ) -> Result<(), NamespaceError> {
        match self.directory.resolve(path.clone()).await {
            Ok(_) => Ok(()),
            Err(NamespaceError::PathNotFound(_)) | Err(NamespaceError::SourceRecovery(_)) => {
                self.register(path, registration).await
            }
            Err(error) => Err(error),
        }
    }

    pub async fn register(
        &self,
        path: DataPath,
        registration: FileRegistration,
    ) -> Result<(), NamespaceError> {
        let source = FileBlobSourceActor::open(
            self.runtime.clone(),
            Arc::clone(&self.source_sender),
            registration.path(),
        )?;
        let length = source.length();
        let recovery = source.recovery();
        let source = self
            .runtime
            .spawn(source)
            .map_err(|error| NamespaceError::SourceRecovery(error.to_string()))?;
        let mut cleanup = PendingSourceRegistration {
            runtime: self.runtime.clone(),
            source,
            armed: true,
        };
        self.source_publisher
            .publish_source(source)
            .map_err(NamespaceError::SourceRecovery)?;
        self.directory
            .register(path, source, length, recovery, random_operation_id())
            .await?;
        cleanup.armed = false;
        Ok(())
    }

    pub async fn unregister(&self, path: DataPath) -> Result<(), NamespaceError> {
        self.directory
            .unregister(path, random_operation_id())
            .await?;
        Ok(())
    }

    pub async fn rename(
        &self,
        source: DataPath,
        destination: DataPath,
        replace: bool,
    ) -> Result<(), NamespaceError> {
        self.directory
            .rename(source, destination, replace, random_operation_id())
            .await?;
        Ok(())
    }
}

struct PendingSourceRegistration {
    runtime: Runtime,
    source: ActorAddress,
    armed: bool,
}

impl Drop for PendingSourceRegistration {
    fn drop(&mut self) {
        if self.armed {
            let _ = self
                .runtime
                .send_to(self.source, BlobSourceIn::Retire { reply_to: None });
        }
    }
}

fn random_operation_id() -> OperationId {
    let actor = ActorAddress::new_random();
    let mut bytes = [0_u8; 16];
    bytes.copy_from_slice(&actor.0[..16]);
    OperationId::from_u128(u128::from_be_bytes(bytes))
}