refactor(rust): extract identity as an entity

examples/rust/file_transfer/Cargo.toml

@@ -10,6 +10,7 @@ rust-version = "1.56.0"
 [dependencies]
 anyhow = "1.0.69"
 ockam = { path = "../../../implementations/rust/ockam/ockam" }
+ockam_transport_tcp = { path = "../../../implementations/rust/ockam/ockam_transport_tcp" }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 structopt = { version = "0.3.25", default-features = false }
 tokio = { version = "1.27.0", features = ["fs", "io-util"] }

examples/rust/file_transfer/examples/receiver.rs

@@ -6,11 +6,9 @@ use ockam::identity::SecureChannelListenerOptions;
 use ockam::remote::RemoteForwarderOptions;
 use ockam::{
     errcode::{Kind, Origin},
-    identity::Identity,
-    remote::RemoteForwarder,
-    vault::Vault,
-    Context, Error, Result, Routed, TcpConnectionOptions, TcpTransport, Worker,
+    node, Context, Error, Result, Routed, TcpConnectionOptions, Worker,
 };
+use ockam_transport_tcp::TcpTransportExtension;
 use tokio::fs::OpenOptions;
 use tokio::io::AsyncWriteExt;
 
@@ -82,19 +80,15 @@ impl Worker for FileReception {
 
 #[ockam::node]
 async fn main(ctx: Context) -> Result<()> {
-    // Initialize the TCP Transport.
-    let tcp = TcpTransport::create(&ctx).await?;
-
-    // Create a Vault to safely store secret keys for Receiver.
-    let vault = Vault::create();
+    let node = node(ctx);
+    let tcp = node.create_tcp_transport().await?;
 
     // Create an Identity to represent Receiver.
-    let receiver = Identity::create(&ctx, vault).await?;
+    let receiver = node.create_identity().await?;
 
     // Create a secure channel listener for Receiver that will wait for requests to
     // initiate an Authenticated Key Exchange.
-    receiver
-        .create_secure_channel_listener("listener", SecureChannelListenerOptions::new())
+    node.create_secure_channel_listener(&receiver, "listener", SecureChannelListenerOptions::new())
         .await?;
 
     // The computer that is running this program is likely within a private network and
@@ -109,13 +103,15 @@ async fn main(ctx: Context) -> Result<()> {
     let node_in_hub = tcp
         .connect("1.node.ockam.network:4000", TcpConnectionOptions::new())
         .await?;
-    let forwarder = RemoteForwarder::create(&ctx, node_in_hub, RemoteForwarderOptions::new()).await?;
+    let forwarder = node
+        .create_forwarder(node_in_hub, RemoteForwarderOptions::new())
+        .await?;
     println!("\n[✓] RemoteForwarder was created on the node at: 1.node.ockam.network:4000");
     println!("Forwarding address for Receiver is:");
     println!("{}", forwarder.remote_address());
 
     // Start a worker, of type FileReception, at address "receiver".
-    ctx.start_worker("receiver", FileReception::default(), AllowAll, AllowAll)
+    node.start_worker("receiver", FileReception::default(), AllowAll, AllowAll)
         .await?;
 
     // We won't call ctx.stop() here, this program will quit when the file will be entirely received

examples/rust/file_transfer/examples/sender.rs

@@ -1,13 +1,14 @@
 // examples/sender.rs
 
 use file_transfer::{FileData, FileDescription};
-use ockam::{identity::Identity, route, vault::Vault, Context};
-use ockam::{TcpConnectionOptions, TcpTransport};
+use ockam::TcpConnectionOptions;
+use ockam::{node, route, Context};
 
 use std::path::PathBuf;
 
 use anyhow::Result;
 use ockam::identity::SecureChannelOptions;
+use ockam_transport_tcp::TcpTransportExtension;
 use structopt::StructOpt;
 use tokio::fs::File;
 use tokio::io::AsyncReadExt;
@@ -32,14 +33,11 @@ struct Opt {
 async fn main(ctx: Context) -> Result<()> {
     let opt = Opt::from_args();
 
-    // Initialize the TCP Transport.
-    let tcp = TcpTransport::create(&ctx).await?;
-
-    // Create a Vault to safely store secret keys for Sender.
-    let vault = Vault::create();
+    let node = node(ctx);
+    let tcp = node.create_tcp_transport().await?;
 
     // Create an Identity to represent Sender.
-    let sender = Identity::create(&ctx, vault).await?;
+    let sender = node.create_identity().await?;
 
     // This program expects that the receiver has setup a forwarding address,
     // for his secure channel listener, on the Ockam node at 1.node.ockam.network:4000.
@@ -58,8 +56,8 @@ async fn main(ctx: Context) -> Result<()> {
 
     // As Sender, connect to the Receiver's secure channel listener, and perform an
     // Authenticated Key Exchange to establish an encrypted secure channel with Receiver.
-    let channel = sender
-        .create_secure_channel(route_to_receiver_listener, SecureChannelOptions::new())
+    let channel = node
+        .create_secure_channel(&sender, route_to_receiver_listener, SecureChannelOptions::new())
         .await?;
 
     println!("\n[✓] End-to-end encrypted secure channel was established.\n");
@@ -80,7 +78,7 @@ async fn main(ctx: Context) -> Result<()> {
         size: metadata.len() as usize,
     });
 
-    ctx.send(route![channel.clone(), "receiver"], descr).await?;
+    node.send(route![channel.clone(), "receiver"], descr).await?;
 
     let mut buffer = vec![0u8; opt.chunk_size];
     loop {
@@ -89,7 +87,7 @@ async fn main(ctx: Context) -> Result<()> {
                 break;
             }
             let data = FileData::Data(buffer[..count].to_vec());
-            ctx.send(route![channel.clone(), "receiver"], data).await?;
+            node.send(route![channel.clone(), "receiver"], data).await?;
         }
     }
 

examples/rust/get_started/Cargo.toml

@@ -37,6 +37,8 @@ ockam = { path = "../../../implementations/rust/ockam/ockam", default_features =
 ockam_api = { path = "../../../implementations/rust/ockam/ockam_api" }
 ockam_core = { path = "../../../implementations/rust/ockam/ockam_core" }
 ockam_multiaddr = { path = "../../../implementations/rust/ockam/ockam_multiaddr" }
+ockam_node = { path = "../../../implementations/rust/ockam/ockam_node" }
+ockam_transport_tcp = { path = "../../../implementations/rust/ockam/ockam_transport_tcp" }
 ockam_transport_udp = { path = "../../../implementations/rust/ockam/ockam_transport_udp" }
 ockam_transport_uds = { path = "../../../implementations/rust/ockam/ockam_transport_uds" }
 ockam_transport_websocket = { path = "../../../implementations/rust/ockam/ockam_transport_websocket", optional = true }