folk-core 0.1.11

Server core for Folk PHP application server — worker pool, plugin registry, admin RPC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! Plugin registry — owns the boot/shutdown ordering.

use anyhow::{Context, Result};
use folk_api::{Plugin, PluginContext};
use tracing::{error, info};

/// Holds plugins and orchestrates their boot/shutdown.
///
/// Boot order: registration order. Shutdown order: reverse.
pub struct PluginRegistry {
    plugins: Vec<Box<dyn Plugin>>,
}

impl PluginRegistry {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new(),
        }
    }

    /// Register a plugin. Plugins are booted in registration order.
    pub fn register(&mut self, plugin: Box<dyn Plugin>) {
        info!(plugin = plugin.name(), "registered");
        self.plugins.push(plugin);
    }

    /// Boot all plugins in order. If any boot returns `Err`, shutdown is
    /// run on already-booted plugins (in reverse) and the error is propagated.
    pub async fn boot_all(&mut self, ctx: &PluginContext) -> Result<()> {
        for (booted_count, plugin) in self.plugins.iter_mut().enumerate() {
            let name = plugin.name();
            info!(plugin = name, "booting");
            if let Err(e) = plugin.boot(ctx.clone()).await {
                error!(plugin = name, error = ?e, "boot failed; rolling back");
                self.shutdown_partial(booted_count).await;
                return Err(e).with_context(|| format!("plugin '{name}' boot failed"));
            }
        }
        Ok(())
    }

    /// Shut down all plugins in reverse order. Errors are logged but do not
    /// stop the shutdown loop.
    pub async fn shutdown_all(&self) {
        self.shutdown_partial(self.plugins.len()).await;
    }

    async fn shutdown_partial(&self, count: usize) {
        for plugin in self.plugins.iter().take(count).rev() {
            let name = plugin.name();
            info!(plugin = name, "shutting down");
            if let Err(e) = plugin.shutdown().await {
                error!(plugin = name, error = ?e, "shutdown error (continuing)");
            }
        }
    }

    pub fn names(&self) -> Vec<&'static str> {
        self.plugins.iter().map(|p| p.name()).collect()
    }
}

impl Default for PluginRegistry {
    fn default() -> Self {
        Self::new()
    }
}