Struct DynamicHub 

pub struct DynamicHub { /* private fields */ }

DynamicHub - an activation that routes to dynamically registered child activations

Unlike hub activations with hardcoded children (like Solar), DynamicHub allows registering activations at runtime via .register().

Direct Hosting

For a single activation, host it directly:

let solar = Arc::new(Solar::new());
TransportServer::builder(solar, converter).serve().await?;

Composition

For multiple top-level activations, use DynamicHub:

let hub = DynamicHub::with_namespace("myapp")
    .register(Solar::new())
    .register(Echo::new());

Implementations

impl DynamicHub

pub fn new(namespace: impl Into<String>) -> DynamicHub

Create a new DynamicHub with explicit namespace

Unlike single activations which have fixed namespaces, DynamicHub is a composition tool that can be named based on your application. Common choices:

• “hub” - generic default
• “substrate” - for substrate server
• “myapp” - for your application name

The namespace appears in method calls: {namespace}.call, {namespace}.schema

pub fn with_namespace(namespace: impl Into<String>) -> DynamicHub

👎Deprecated since 0.3.0: Use DynamicHub::new(namespace) instead

Deprecated: Use new() with explicit namespace instead

pub fn runtime_namespace(&self) -> &str

Get the runtime namespace for this DynamicHub instance

pub fn registry(&self) -> RwLockReadGuard<'_, PluginRegistry>

Get access to the activation registry

pub fn register<A>(self, activation: A) -> DynamicHub

where A: Activation + Clone,

Register an activation

pub fn register_hub<A>(self, activation: A) -> DynamicHub

where A: Activation + ChildRouter + Clone + 'static,

Register a hub activation that supports nested routing

Hub activations implement ChildRouter, enabling direct nested method calls like hub.solar.mercury.info at the RPC layer (no hub.call indirection).

pub fn list_methods(&self) -> Vec<String>

List all methods across all activations

pub fn list_activations_info(&self) -> Vec<ActivationInfo>

List all activations (including this hub itself)

pub fn compute_hash(&self) -> String

Compute hash for cache invalidation

Returns the hash from the recursive plugin schema. This hash changes whenever any method definition or child plugin changes.

pub async fn route( &self, method: &str, params: Value, ) -> Result<Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>, PlexusError>

Route a call to the appropriate activation

pub async fn do_resolve_handle( &self, handle: &Handle, ) -> Result<Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>, PlexusError>

Resolve a handle using the activation registry

Looks up the activation by its UUID in the registry.

pub fn get_activation_schema(&self, namespace: &str) -> Option<Schema>

Get activation schema

pub fn registry_snapshot(&self) -> PluginRegistrySnapshot

Get a snapshot of the activation registry (safe to use outside locks)

pub fn lookup_plugin(&self, id: Uuid) -> Option<String>

Look up an activation path by its UUID

pub fn lookup_plugin_by_path(&self, path: &str) -> Option<Uuid>

Look up an activation UUID by its path

pub fn list_plugin_schemas(&self) -> Vec<PluginSchema>

Get activation schemas for all activations (including this hub itself)

pub fn list_full_schemas(&self) -> Vec<PluginSchema>

👎Deprecated: Use list_plugin_schemas instead

Deprecated: use list_plugin_schemas instead

pub fn get_method_help(&self, method: &str) -> Option<String>

Get help for a method

pub fn plugin_children(&self) -> Vec<ChildSummary>

Get child activation summaries (for hub functionality) Called by hub-macro when hub flag is set

pub fn into_rpc_module(self) -> Result<RpcModule<()>, RegisterMethodError>

Convert to RPC module

pub fn arc_into_rpc_module( hub: Arc<DynamicHub>, ) -> Result<RpcModule<()>, RegisterMethodError>

Convert Arc to RPC module while keeping the Arc alive

Unlike into_rpc_module, this keeps the Arc reference alive, which is necessary when activations hold Weak references that need to remain upgradeable.

impl DynamicHub

pub const NAMESPACE: &'static str = "plexus"

pub const PLUGIN_ID: Uuid

Stable plugin instance ID for handle routing

pub fn plugin_id(&self) -> Uuid

Get the plugin’s stable instance ID

Trait Implementations

impl Activation for DynamicHub

type Methods = DynamicHubMethod

fn namespace(&self) -> &str

fn version(&self) -> &str

fn description(&self) -> &str

Short description (max 15 words)

fn long_description(&self) -> Option<&str>

Long description (optional, for detailed documentation)

fn methods(&self) -> Vec<&str>

fn method_help(&self, method: &str) -> Option<String>

fn call<'life0, 'life1, 'async_trait>( &'life0 self, method: &'life1 str, params: Value, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>, PlexusError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DynamicHub: 'async_trait,

fn into_rpc_methods(self) -> Methods

fn plugin_schema(&self) -> PluginSchema

Return this activation’s schema (methods + optional children)

fn plugin_id(&self) -> Uuid

Stable activation instance ID for handle routing By default generates a deterministic UUID from namespace+major_version Using major version only ensures handles survive minor/patch upgrades (semver)

fn resolve_handle<'life0, 'life1, 'async_trait>( &'life0 self, _handle: &'life1 Handle, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>, PlexusError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

impl ChildRouter for DynamicHub

ChildRouter implementation for DynamicHub

This enables nested routing through registered activations. e.g., hub.call(“solar.mercury.info”) routes to solar → mercury → info

fn router_namespace(&self) -> &str

Get the namespace of this router (for error messages)

fn router_call<'life0, 'life1, 'async_trait>( &'life0 self, method: &'life1 str, params: Value, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>, PlexusError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DynamicHub: 'async_trait,

Call a method on this router

fn get_child<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Option<Box<dyn ChildRouter>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, DynamicHub: 'async_trait,

Get a child activation instance by name for nested routing

impl Clone for DynamicHub

fn clone(&self) -> DynamicHub

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DynamicHubRpcServer for DynamicHub

fn call<'life0, 'async_trait>( &'life0 self, pending: PendingSubscriptionSink, method: String, params: Option<Value>, ) -> Pin<Box<dyn Future<Output = Result<(), SubscriptionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, DynamicHub: 'async_trait,

Route a call to a registered activation

fn hash<'life0, 'async_trait>( &'life0 self, pending: PendingSubscriptionSink, ) -> Pin<Box<dyn Future<Output = Result<(), SubscriptionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, DynamicHub: 'async_trait,

Get Plexus RPC server configuration hash (from the recursive schema) This hash changes whenever any method or child activation changes. It’s computed from the method hashes rolled up through the schema tree.

fn into_rpc(self) -> RpcModule<Self>

Collects all the methods and subscriptions defined in the trait and adds them into a single RpcModule.