Method create_spec

flow-rs/src/node/port.rs:90–136

(
        &mut self,
        key: u64,
        which: &str,
        resource: ResourceCollection,
        args: Table,
    )

    }

    pub async fn create_spec(
        &mut self,
        key: u64,
        which: &str,
        resource: ResourceCollection,
        args: Table,
    ) -> Result<JoinHandle<Result<()>>> {
        let broker = self
            .brokers
            .get(which)
            .ok_or_else(|| anyhow!("{} not found", which))?;
        if let Some(slice) = GraphSlice::registry_local()
            .get(self.local_key)
            .get(broker.topic())
        {
            let args = merge_table(self.args.clone(), args);
            let mut g = (slice.cons)(format!("{}_instance", broker.topic()), &args)?;

            let mut inputs = HashMap::new();
            let mut outputs = HashMap::new();

            for input in &slice.info.inputs {
                let channel = ChannelStorage::bound(self.cap);
                g.set_port(input.as_str(), None, &channel);
                inputs.insert(input.clone(), channel.sender());
            }

            for output in &slice.info.outputs {
                let channel = ChannelStorage::bound(self.cap);
                g.set_port(output.as_str(), None, &channel);
                outputs.insert(output.clone(), channel.receiver());
            }

            let handle = g.start(Some(resource));

            broker
                .publish(DynConns {
                    name: key,
                    inputs,
                    outputs,
                })
                .await;
            Ok(handle)
        } else {
            Err(anyhow!("{} not found", broker.topic()))
        }
    }
}

impl DynPorts<Receiver> {