Update rust library examples

reference/libraries/rust/credentials.md

@@ -42,6 +42,7 @@ In a later guide, we'll explore how Ockam enables you to define various pluggabl
 
 {% code lineNumbers="true" %}
 ```rust
+// examples/06-credentials-exchange-issuer.rs
 use ockam::access_control::AllowAll;
 use ockam::access_control::IdentityIdAccessControl;
 use ockam::identity::CredentialsIssuer;
@@ -112,6 +113,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("issuer started");
     Ok(())
 }
+
 ```
 {% endcode %}
 
@@ -127,6 +129,7 @@ touch examples/06-credential-exchange-server.rs
 
 {% code lineNumbers="true" %}
 ```rust
+// examples/06-credentials-exchange-server.rs
 // This node starts a tcp listener, a secure channel listener, and an echoer worker.
 // It then runs forever waiting for messages.
 use hello_ockam::Echoer;
@@ -222,6 +225,7 @@ async fn main(ctx: Context) -> Result<()> {
     println!("server started");
     Ok(())
 }
+
 ```
 {% endcode %}
 
@@ -237,6 +241,7 @@ touch examples/06-credential-exchange-client.rs
 
 {% code lineNumbers="true" %}
 ```rust
+// examples/06-credentials-exchange-client.rs
 use ockam::identity::{AuthorityService, CredentialsIssuerClient, SecureChannelOptions, TrustContext};
 use ockam::TcpTransportExtension;
 use ockam::{node, route, Context, Result, TcpConnectionOptions};
@@ -318,6 +323,7 @@ async fn main(ctx: Context) -> Result<()> {
 
     node.stop().await
 }
+
 ```
 {% endcode %}
 

reference/libraries/rust/nodes.md

@@ -51,6 +51,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop the node as soon as it starts.
     node.stop().await
 }
+
 ```
 
 Here we add the `#[ockam::node]` attribute to an `async` main function that receives the node execution context as a parameter and returns `ockam::Result` which helps make our error reporting better.
@@ -97,7 +98,6 @@ Add the following code to this file:
 
 ```rust
 // src/echoer.rs
-
 use ockam::{Context, Result, Routed, Worker};
 
 pub struct Echoer;
@@ -114,6 +114,7 @@ impl Worker for Echoer {
         ctx.send(msg.return_route(), msg.body()).await
     }
 }
+
 ```
 
 Note that we define the `Message` associated type of the worker as `String`, which specifies that this worker expects to handle `String` messages. We then go on to define a `handle_message(..)` function that will be called whenever a new message arrives for this worker.
@@ -123,10 +124,10 @@ In the Echoer's `handle_message(..)`, we print any incoming message, along with
 To make this Echoer type accessible to our main program, export it from `src/lib.rs` file by adding the following to it:
 
 ```rust
-// src/lib.rs
-
 mod echoer;
+
 pub use echoer::*;
+
 ```
 
 #### App worker
@@ -168,6 +169,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 To run this new node program:

reference/libraries/rust/routing.md

@@ -79,8 +79,7 @@ Add the following code to this file:
 
 ```rust
 // src/hop.rs
-
-use ockam::{Any, Context, Result, Routed, Worker};
+use ockam::{Any, Context, LocalMessage, Result, Routed, Worker};
 
 pub struct Hop;
 
@@ -95,19 +94,22 @@ impl Worker for Hop {
         println!("Address: {}, Received: {}", ctx.address(), msg);
 
         // Some type conversion
-        let mut message = msg.into_local_message();
-        let transport_message = message.transport_mut();
+        let mut transport_message = msg.into_local_message().into_transport_message();
 
         // Remove my address from the onward_route
         transport_message.onward_route.step()?;
 
         // Insert my address at the beginning return_route
         transport_message.return_route.modify().prepend(ctx.address());
 
+        // Wipe all local info (e.g. transport types)
+        let message = LocalMessage::new(transport_message, vec![]);
+
         // Send the message on its onward_route
         ctx.forward(message).await
     }
 }
+
 ```
 
 To make this `Hop` type accessible to our main program, export it from `src/lib.rs` by adding the following to it:
@@ -164,6 +166,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 To run this new node program:
@@ -221,6 +224,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 To run this new node program:
@@ -253,7 +257,6 @@ Add the following code to this file:
 // It then runs forever waiting for messages.
 
 use hello_ockam::Echoer;
-use ockam::flow_control::FlowControlPolicy;
 use ockam::{node, Context, Result, TcpListenerOptions, TcpTransportExtension};
 
 #[ockam::node]
@@ -276,6 +279,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Don't call node.stop() here so this node runs forever.
     Ok(())
 }
+
 ```
 
 #### Initiator node
@@ -315,6 +319,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 #### Run
@@ -357,7 +362,6 @@ Add the following code to this file:
 
 ```rust
 // src/forwarder.rs
-
 use ockam::{Address, Any, Context, LocalMessage, Result, Routed, Worker};
 
 pub struct Forwarder(pub Address);
@@ -399,6 +403,7 @@ impl Worker for Forwarder {
         ctx.forward(message).await
     }
 }
+
 ```
 
 To make this `Forwarder` type accessible to our main program, export it from `src/lib.rs` by adding the following to it:
@@ -424,7 +429,6 @@ Add the following code to this file:
 // It then runs forever waiting for messages.
 
 use hello_ockam::Echoer;
-use ockam::flow_control::FlowControlPolicy;
 use ockam::{node, Context, Result, TcpListenerOptions, TcpTransportExtension};
 
 #[ockam::node]
@@ -447,6 +451,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Don't call node.stop() here so this node runs forever.
     Ok(())
 }
+
 ```
 
 #### Middle node
@@ -494,6 +499,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Don't call node.stop() here so this node runs forever.
     Ok(())
 }
+
 ```
 
 #### Initiator node
@@ -532,6 +538,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 #### Run

reference/libraries/rust/secure-channels.md

@@ -66,6 +66,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Don't call node.stop() here so this node runs forever.
     Ok(())
 }
+
 ```
 
 ### Middle node
@@ -112,6 +113,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Don't call node.stop() here so this node runs forever.
     Ok(())
 }
+
 ```
 
 ### Initiator node
@@ -160,6 +162,7 @@ async fn main(ctx: Context) -> Result<()> {
     // Stop all workers, stop the node, cleanup and return.
     node.stop().await
 }
+
 ```
 
 ### Run

reference/libraries/rust/vaults-and-identities.md

@@ -7,6 +7,7 @@ description: >-
 # Vaults and Identities
 
 ```rust
+// examples/vault-and-identities.rs
 use ockam::node;
 use ockam::{Context, Result};
 
@@ -16,9 +17,10 @@ async fn main(ctx: Context) -> Result<()> {
     let mut node = node(ctx);
 
     // Create an Identity to represent Alice.
-    let alice = node.create_identity().await?;
+    let _alice = node.create_identity().await?;
 
     // Stop the node.
     node.stop().await
 }
+
 ```