update docs on release to ockam ref ockam_v0.147.0

Author: actions-user

reference/libraries/rust/credentials.md

@@ -74,7 +74,7 @@ async fn main(ctx: Context) -> Result<()> {
     let mut vault = Vault::create().await?;
     vault.identity_vault = identity_vault;
 
-    let node = Node::builder().await?.with_vault(vault).build(&ctx).await?;
+    let node = Node::builder().await?.with_vault(vault).build(&ctx)?;
 
     let issuer_identity = hex::decode("81825837830101583285f68200815820afbca9cf5d440147450f9f0d0a038a337b3fe5c17086163f2c54509558b62ef4f41a654cf97d1a7818fc7d8200815840650c4c939b96142546559aed99c52b64aa8a2f7b242b46534f7f8d0c5cc083d2c97210b93e9bca990e9cb9301acc2b634ffb80be314025f9adc870713e6fde0d").unwrap();
     let issuer = node.import_private_identity(None, &issuer_identity, &secret).await?;
@@ -121,7 +121,7 @@ async fn main(ctx: Context) -> Result<()> {
         pre_trusted_identities.insert(identifier.clone(), attributes.clone());
     }
     members
-        .bootstrap_pre_trusted_members(&pre_trusted_identities.into())
+        .bootstrap_pre_trusted_members(&issuer, &pre_trusted_identities.into())
         .await?;
 
     let tcp_listener_options = TcpListenerOptions::new();
@@ -132,27 +132,25 @@ async fn main(ctx: Context) -> Result<()> {
     // Start a secure channel listener that only allows channels where the identity
     // at the other end of the channel can authenticate with the latest private key
     // corresponding to one of the above known public identifiers.
-    node.create_secure_channel_listener(&issuer, DefaultAddress::SECURE_CHANNEL_LISTENER, sc_listener_options)
-        .await?;
+    node.create_secure_channel_listener(&issuer, DefaultAddress::SECURE_CHANNEL_LISTENER, sc_listener_options)?;
 
     // Start a credential issuer worker that will only accept incoming requests from
     // authenticated secure channels with our known public identifiers.
     let allow_known = IdentityIdAccessControl::new(known_identifiers);
     node.flow_controls()
-        .add_consumer(DefaultAddress::CREDENTIAL_ISSUER, &sc_listener_flow_control_id);
+        .add_consumer(&DefaultAddress::CREDENTIAL_ISSUER.into(), &sc_listener_flow_control_id);
     node.start_worker_with_access_control(
         DefaultAddress::CREDENTIAL_ISSUER,
         credential_issuer,
         allow_known,
         AllowAll,
-    )
-    .await?;
+    )?;
 
     // Initialize TCP Transport, create a TCP listener, and wait for connections.
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
     tcp.listen("127.0.0.1:5000", tcp_listener_options).await?;
 
-    // Don't call node.stop() here so this node runs forever.
+    // Don't call node.shutdown() here so this node runs forever.
     println!("issuer started");
     Ok(())
 }
@@ -203,10 +201,10 @@ async fn main(ctx: Context) -> Result<()> {
     let mut vault = Vault::create().await?;
     vault.identity_vault = identity_vault;
 
-    let node = Node::builder().await?.with_vault(vault).build(&ctx).await?;
+    let node = Node::builder().await?.with_vault(vault).build(&ctx)?;
 
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create an Identity representing the server
     // Load an identity corresponding to the following public identifier
@@ -256,7 +254,7 @@ async fn main(ctx: Context) -> Result<()> {
         .as_consumer(&tcp_listener_options.spawner_flow_control_id());
 
     node.flow_controls().add_consumer(
-        DefaultAddress::ECHO_SERVICE,
+        &DefaultAddress::ECHO_SERVICE.into(),
         &sc_listener_options.spawner_flow_control_id(),
     );
     let allow_production_incoming = IncomingAbac::create_name_value(
@@ -271,25 +269,22 @@ async fn main(ctx: Context) -> Result<()> {
         Some(issuer),
         "cluster",
         "production",
-    )
-    .await?;
+    )?;
     node.start_worker_with_access_control(
         DefaultAddress::ECHO_SERVICE,
         Echoer,
         allow_production_incoming,
         allow_production_outgoing,
-    )
-    .await?;
+    )?;
 
     // Start a secure channel listener that only allows channels with
     // authenticated identities.
-    node.create_secure_channel_listener(&server, DefaultAddress::SECURE_CHANNEL_LISTENER, sc_listener_options)
-        .await?;
+    node.create_secure_channel_listener(&server, DefaultAddress::SECURE_CHANNEL_LISTENER, sc_listener_options)?;
 
     // Create a TCP listener and wait for incoming connections
     tcp.listen("127.0.0.1:4000", tcp_listener_options).await?;
 
-    // Don't call node.stop() here so this node runs forever.
+    // Don't call node.shutdown() here so this node runs forever.
     println!("server started");
     Ok(())
 }
@@ -311,13 +306,14 @@ touch examples/06-credential-exchange-client.rs
 ```rust
 // examples/06-credentials-exchange-client.rs
 use ockam::identity::{SecureChannelOptions, Vault};
-use ockam::tcp::{TcpConnectionOptions, TcpTransportExtension};
+use ockam::tcp::TcpConnectionOptions;
 use ockam::vault::{EdDSACurve25519SecretKey, SigningSecret, SoftwareVaultForSigning};
 use ockam::{route, Context, Node, Result};
 use ockam_api::enroll::enrollment::Enrollment;
 use ockam_api::nodes::NodeManager;
 use ockam_api::DefaultAddress;
 use ockam_multiaddr::MultiAddr;
+use ockam_transport_tcp::TcpTransportExtension;
 
 #[ockam::node]
 async fn main(ctx: Context) -> Result<()> {
@@ -336,9 +332,9 @@ async fn main(ctx: Context) -> Result<()> {
     let mut vault = Vault::create().await?;
     vault.identity_vault = identity_vault;
 
-    let mut node = Node::builder().await?.with_vault(vault).build(&ctx).await?;
+    let mut node = Node::builder().await?.with_vault(vault).build(&ctx)?;
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create an Identity representing the client
     // We preload the client vault with a change history and secret key corresponding to the identity identifier
@@ -400,7 +396,7 @@ async fn main(ctx: Context) -> Result<()> {
         .await?;
     println!("Received: {}", reply); // should print "Hello Ockam!"
 
-    node.stop().await
+    node.shutdown().await
 }
 
 ```

reference/libraries/rust/nodes.md

@@ -50,7 +50,7 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Stop the node as soon as it starts.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```
@@ -113,7 +113,7 @@ impl Worker for Echoer {
     type Message = String;
 
     async fn handle_message(&mut self, ctx: &mut Context, msg: Routed<String>) -> Result<()> {
-        println!("Address: {}, Received: {:?}", ctx.address(), msg);
+        println!("Address: {}, Received: {:?}", ctx.primary_address(), msg);
 
         // Echo the message body back on its return_route.
         ctx.send(msg.return_route().clone(), msg.into_body()?).await
@@ -162,7 +162,7 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Start a worker, of type Echoer, at address "echoer"
-    node.start_worker("echoer", Echoer).await?;
+    node.start_worker("echoer", Echoer)?;
 
     // Send a message to the worker at address "echoer".
     node.send("echoer", "Hello Ockam!".to_string()).await?;
@@ -172,7 +172,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("App Received: {}", reply.into_body()?); // should print "Hello Ockam!"
 
     // Stop all workers, stop the node, cleanup and return.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```

reference/libraries/rust/routing.md

@@ -88,10 +88,10 @@ impl Worker for Hop {
     /// This handle function takes any incoming message and forwards
     /// it to the next hop in it's onward route
     async fn handle_message(&mut self, ctx: &mut Context, msg: Routed<Any>) -> Result<()> {
-        println!("Address: {}, Received: {:?}", ctx.address(), msg);
+        println!("Address: {}, Received: {:?}", ctx.primary_address(), msg);
 
         // Send the message to the next worker on its onward_route
-        ctx.forward(msg.into_local_message().step_forward(&ctx.address())?)
+        ctx.forward(msg.into_local_message().step_forward(ctx.primary_address().clone())?)
             .await
     }
 }
@@ -136,10 +136,10 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Start a worker, of type Echoer, at address "echoer"
-    node.start_worker("echoer", Echoer).await?;
+    node.start_worker("echoer", Echoer)?;
 
     // Start a worker, of type Hop, at address "h1"
-    node.start_worker("h1", Hop).await?;
+    node.start_worker("h1", Hop)?;
 
     // Send a message to the worker at address "echoer",
     // via the worker at address "h1"
@@ -150,7 +150,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("App Received: {}", reply.into_body()?); // should print "Hello Ockam!"
 
     // Stop all workers, stop the node, cleanup and return.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```
@@ -190,12 +190,12 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Start an Echoer worker at address "echoer"
-    node.start_worker("echoer", Echoer).await?;
+    node.start_worker("echoer", Echoer)?;
 
     // Start 3 hop workers at addresses "h1", "h2" and "h3".
-    node.start_worker("h1", Hop).await?;
-    node.start_worker("h2", Hop).await?;
-    node.start_worker("h3", Hop).await?;
+    node.start_worker("h1", Hop)?;
+    node.start_worker("h2", Hop)?;
+    node.start_worker("h3", Hop)?;
 
     // Send a message to the echoer worker via the "h1", "h2", and "h3" workers
     let r = route!["h1", "h2", "h3", "echoer"];
@@ -206,7 +206,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("App Received: {}", reply.into_body()?); // should print "Hello Ockam!"
 
     // Stop all workers, stop the node, cleanup and return.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```
@@ -250,18 +250,19 @@ async fn main(ctx: Context) -> Result<()> {
     let node = node(ctx).await?;
 
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create an echoer worker
-    node.start_worker("echoer", Echoer).await?;
+    node.start_worker("echoer", Echoer)?;
 
     // Create a TCP listener and wait for incoming connections.
     let listener = tcp.listen("127.0.0.1:4000", TcpListenerOptions::new()).await?;
 
     // Allow access to the Echoer via TCP connections from the TCP listener
-    node.flow_controls().add_consumer("echoer", listener.flow_control_id());
+    node.flow_controls()
+        .add_consumer(&"echoer".into(), listener.flow_control_id());
 
-    // Don't call node.stop() here so this node runs forever.
+    // Don't call node.shutdown() here so this node runs forever.
     Ok(())
 }
 
@@ -290,7 +291,7 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Initialize the TCP Transport.
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create a TCP connection to a different node.
     let connection_to_responder = tcp.connect("localhost:4000", TcpConnectionOptions::new()).await?;
@@ -303,7 +304,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("App Received: {}", reply); // should print "Hello Ockam!"
 
     // Stop all workers, stop the node, cleanup and return.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```
@@ -374,28 +375,27 @@ impl Worker for Relay {
     /// This handle function takes any incoming message and forwards
     /// it to the next hop in it's onward route
     async fn handle_message(&mut self, ctx: &mut Context, msg: Routed<Any>) -> Result<()> {
-        println!("Address: {}, Received: {:?}", ctx.address(), msg);
+        println!("Address: {}, Received: {:?}", ctx.primary_address(), msg);
 
         let next_on_route = self.route.next()?.clone();
 
         // Some type conversion
         let mut local_message = msg.into_local_message();
 
         local_message = local_message.pop_front_onward_route()?;
-        local_message = local_message.prepend_front_onward_route(&self.route); // Prepend predefined route to the onward_route
+        local_message = local_message.prepend_front_onward_route(self.route.clone()); // Prepend predefined route to the onward_route
 
         let prev_hop = local_message.return_route().next()?.clone();
 
         if let Some(info) = ctx
             .flow_controls()
             .find_flow_control_with_producer_address(&next_on_route)
         {
-            ctx.flow_controls()
-                .add_consumer(prev_hop.clone(), info.flow_control_id());
+            ctx.flow_controls().add_consumer(&prev_hop, info.flow_control_id());
         }
 
         if let Some(info) = ctx.flow_controls().find_flow_control_with_producer_address(&prev_hop) {
-            ctx.flow_controls().add_consumer(next_on_route, info.flow_control_id());
+            ctx.flow_controls().add_consumer(&next_on_route, info.flow_control_id());
         }
 
         // Send the message on its onward_route
@@ -437,18 +437,19 @@ async fn main(ctx: Context) -> Result<()> {
     let node = node(ctx).await?;
 
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create an echoer worker
-    node.start_worker("echoer", Echoer).await?;
+    node.start_worker("echoer", Echoer)?;
 
     // Create a TCP listener and wait for incoming connections.
     let listener = tcp.listen("127.0.0.1:4000", TcpListenerOptions::new()).await?;
 
     // Allow access to the Echoer via TCP connections from the TCP listener
-    node.flow_controls().add_consumer("echoer", listener.flow_control_id());
+    node.flow_controls()
+        .add_consumer(&"echoer".into(), listener.flow_control_id());
 
-    // Don't call node.stop() here so this node runs forever.
+    // Don't call node.shutdown() here so this node runs forever.
     Ok(())
 }
 
@@ -481,23 +482,22 @@ async fn main(ctx: Context) -> Result<()> {
     let node = node(ctx).await?;
 
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create a TCP connection to the responder node.
     let connection_to_responder = tcp.connect("127.0.0.1:4000", TcpConnectionOptions::new()).await?;
 
     // Create and start a Relay worker
-    node.start_worker("forward_to_responder", Relay::new(connection_to_responder))
-        .await?;
+    node.start_worker("forward_to_responder", Relay::new(connection_to_responder))?;
 
     // Create a TCP listener and wait for incoming connections.
     let listener = tcp.listen("127.0.0.1:3000", TcpListenerOptions::new()).await?;
 
     // Allow access to the Relay via TCP connections from the TCP listener
     node.flow_controls()
-        .add_consumer("forward_to_responder", listener.flow_control_id());
+        .add_consumer(&"forward_to_responder".into(), listener.flow_control_id());
 
-    // Don't call node.stop() here so this node runs forever.
+    // Don't call node.shutdown() here so this node runs forever.
     Ok(())
 }
 
@@ -526,7 +526,7 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx).await?;
 
     // Initialize the TCP Transport
-    let tcp = node.create_tcp_transport().await?;
+    let tcp = node.create_tcp_transport()?;
 
     // Create a TCP connection to the middle node.
     let connection_to_middle_node = tcp.connect("localhost:3000", TcpConnectionOptions::new()).await?;
@@ -538,7 +538,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("App Received: {}", reply); // should print "Hello Ockam!"
 
     // Stop all workers, stop the node, cleanup and return.
-    node.stop().await
+    node.shutdown().await
 }
 
 ```