src/connectivity/network/testing/netemul/runner/test/netstack_intermediary/src/main.rs - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 use {
     anyhow::{format_err, Context as _, Error},
     ethernet,
     fidl_fuchsia_netemul_network::{
         EndpointManagerMarker, FakeEndpointMarker, NetworkContextMarker, NetworkManagerMarker,
     },
     fidl_fuchsia_netemul_sync::{BusMarker, BusProxy, SyncManagerMarker},
     fidl_fuchsia_netstack::{InterfaceConfig, NetstackMarker},
     fuchsia_async as fasync,
     fuchsia_component::client,
     fuchsia_zircon as zx,
     futures::{self, TryStreamExt},
     std::{str, task::Poll},
     structopt::StructOpt,
 };

 #[derive(StructOpt, Debug)]
 struct Opt {
     #[structopt(long = "mock_guest")]
     is_mock_guest: bool,
     #[structopt(long = "server")]
     is_server: bool,
     #[structopt(long)]
     network_name: Option<String>,
     #[structopt(long)]
     endpoint_name: Option<String>,
     #[structopt(long)]
     server_name: Option<String>,
 }

 const DEFAULT_METRIC: u32 = 100;
 const BUS_NAME: &'static str = "netstack-itm-bus";

 fn open_bus(cli_name: &str) -> Result<BusProxy, Error> {
     let syncm = client::connect_to_service::<SyncManagerMarker>()?;
     let (bus, bus_server_end) = fidl::endpoints::create_proxy::<BusMarker>()?;
     syncm.bus_subscribe(BUS_NAME, cli_name, bus_server_end)?;
     Ok(bus)
 }

 async fn run_mock_guest(
     network_name: String,
     ep_name: String,
     server_name: String,
 ) -> Result<(), Error> {
     // Create an ethertap client and an associated ethernet device.
     let ctx = client::connect_to_service::<NetworkContextMarker>()?;
     let (epm, epm_server_end) = fidl::endpoints::create_proxy::<EndpointManagerMarker>()?;
     ctx.get_endpoint_manager(epm_server_end)?;
     let (netm, netm_server_end) = fidl::endpoints::create_proxy::<NetworkManagerMarker>()?;
     ctx.get_network_manager(netm_server_end)?;

     let ep = epm.get_endpoint(&ep_name).await?.unwrap().into_proxy()?;
     let net = netm.get_network(&network_name).await?.unwrap().into_proxy()?;
     let (fake_ep, fake_ep_server_end) = fidl::endpoints::create_proxy::<FakeEndpointMarker>()?;
     net.create_fake_endpoint(fake_ep_server_end)?;

     let netstack = client::connect_to_service::<NetstackMarker>()?;
     let mut cfg = InterfaceConfig {
         name: "eth-test".to_string(),
         filepath: "[TBD]".to_string(),
         metric: DEFAULT_METRIC,
     };

     let _nicid = match ep.get_device().await? {
         fidl_fuchsia_netemul_network::DeviceConnection::Ethernet(eth_device) => {
             netstack.add_ethernet_device(&format!("/{}", ep_name), &mut cfg, eth_device).await?
         }
         fidl_fuchsia_netemul_network::DeviceConnection::NetworkDevice(netdevice) => {
             todo!("(48860) Support and test for NetworkDevice connections. Got unexpected NetworkDevice {:?}", netdevice)
         }
     };

     // Send a message to the server and expect it to be echoed back.
     let echo_string = String::from("hello");

     let bus = open_bus(&ep_name)?;
     let (success, absent) =
         bus.wait_for_clients(&mut vec![server_name.as_str()].drain(..), 0).await?;
     assert!(success);
     assert_eq!(absent, None);

     fake_ep.write(echo_string.as_bytes()).await.context("write failed")?;

     println!("To Server: {}", echo_string);

     let (data, dropped_frames) = fake_ep.read().await.context("read failed")?;
     assert_eq!(dropped_frames, 0);
     let server_string = str::from_utf8(&data)?;
     assert!(
         echo_string == server_string,
         "Server reply ({}) did not match client message ({})",
         server_string,
         echo_string
     );
     println!("From Server: {}", server_string);

     Ok(())
 }

 async fn run_echo_server_ethernet(
     ep_name: String,
     eth_dev: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_ethernet::DeviceMarker>,
 ) -> Result<(), Error> {
     // Create an EthernetClient to wrap around the Endpoint's ethernet device.
     let vmo = zx::Vmo::create(256 * ethernet::DEFAULT_BUFFER_SIZE as u64)?;

     let eth_proxy = match eth_dev.into_proxy() {
         Ok(proxy) => proxy,
         _ => return Err(format_err!("Could not get ethernet proxy")),
     };

     let mut eth_client =
         ethernet::Client::new(eth_proxy, vmo, ethernet::DEFAULT_BUFFER_SIZE, &ep_name).await?;

     eth_client.start().await?;

     // Listen for a receive event from the client, echo back the client's
     // message, and then exit.
     let mut eth_events = eth_client.get_stream();
     let mut sent_response = false;

     // Before connecting to the message bus to notify the client of the server's existence, poll
     // for events.  Buffers will not be allocated until polling is performed so this ensures that
     // there will be buffers to receive the client's message.
     loop {
         match futures::poll!(eth_events.try_next()) {
             Poll::Pending => break,
             Poll::Ready(result) => match result {
                 Ok(result) => match result {
                     Some(_) => continue,
                     None => panic!("event stream produced empty event"),
                 },
                 Err(e) => panic!("event stream returned an error: {}", e),
             },
         }
     }

     // get on bus to unlock mock_guest part of test
     let _bus = open_bus(&ep_name)?;

     while let Some(event) = eth_events.try_next().await? {
         match event {
             ethernet::Event::Receive(rx, _flags) => {
                 if !sent_response {
                     let mut data: [u8; 100] = [0; 100];
                     let sz = rx.read(&mut data);
                     let user_message =
                         str::from_utf8(&data[0..sz]).expect("failed to parse string");
                     println!("From client: {}", user_message);
                     let () = eth_client.send(&data[0..sz]);
                     sent_response = true;

                     // Start listening for the server's response to be
                     // transmitted to the guest.
                     eth_client.tx_listen_start().await?;
                 } else {
                     // The mock guest will not send anything to the server
                     // beyond its initial request.  After the server has echoed
                     // the response, the next received message will be the
                     // server's own output since it is listening for its own
                     // Tx messages.
                     break;
                 }
             }
             _ => {
                 continue;
             }
         }
     }

     Ok(())
 }

 async fn run_echo_server(ep_name: String) -> Result<(), Error> {
     // Get the Endpoint that was created in the server's environment.
     let netctx = client::connect_to_service::<NetworkContextMarker>()?;
     let (epm, epm_server_end) = fidl::endpoints::create_proxy::<EndpointManagerMarker>()?;
     netctx.get_endpoint_manager(epm_server_end)?;

     let ep = epm.get_endpoint(&ep_name).await?;

     let ep = match ep {
         Some(ep) => ep.into_proxy()?,
         None => return Err(format_err!("Can't find endpoint {}", &ep_name)),
     };

     match ep.get_device().await? {
         fidl_fuchsia_netemul_network::DeviceConnection::Ethernet(e) => {
             run_echo_server_ethernet(ep_name, e).await
         }
         fidl_fuchsia_netemul_network::DeviceConnection::NetworkDevice(netdevice) => {
             todo!("(48860) Support and test for NetworkDevice connections. Got unexpected NetworkDevice {:?}", netdevice)
         }
     }
 }

 #[fasync::run_singlethreaded]
 async fn main() -> Result<(), Error> {
     let opt = Opt::from_args();

     if opt.is_mock_guest {
         if opt.network_name == None || opt.endpoint_name == None || opt.server_name == None {
             return Err(format_err!(
                 "Must provide network_name, endpoint_name, and server_name for mock guests"
             ));
         }
         run_mock_guest(
             opt.network_name.unwrap(),
             opt.endpoint_name.unwrap(),
             opt.server_name.unwrap(),
         )
         .await?;
     } else if opt.is_server {
         match opt.endpoint_name {
             Some(endpoint_name) => {
                 run_echo_server(endpoint_name).await?;
             }
             None => {
                 return Err(format_err!("Must provide endpoint_name for server"));
             }
         }
     }
     Ok(())
 }
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	use {
	anyhow::{format_err, Context as _, Error},
	ethernet,
	fidl_fuchsia_netemul_network::{
	EndpointManagerMarker, FakeEndpointMarker, NetworkContextMarker, NetworkManagerMarker,
	},
	fidl_fuchsia_netemul_sync::{BusMarker, BusProxy, SyncManagerMarker},
	fidl_fuchsia_netstack::{InterfaceConfig, NetstackMarker},
	fuchsia_async as fasync,
	fuchsia_component::client,
	fuchsia_zircon as zx,
	futures::{self, TryStreamExt},
	std::{str, task::Poll},
	structopt::StructOpt,
	};

	#[derive(StructOpt, Debug)]
	struct Opt {
	#[structopt(long = "mock_guest")]
	is_mock_guest: bool,
	#[structopt(long = "server")]
	is_server: bool,
	#[structopt(long)]
	network_name: Option<String>,
	#[structopt(long)]
	endpoint_name: Option<String>,
	#[structopt(long)]
	server_name: Option<String>,
	}

	const DEFAULT_METRIC: u32 = 100;
	const BUS_NAME: &'static str = "netstack-itm-bus";

	fn open_bus(cli_name: &str) -> Result<BusProxy, Error> {
	let syncm = client::connect_to_service::<SyncManagerMarker>()?;
	let (bus, bus_server_end) = fidl::endpoints::create_proxy::<BusMarker>()?;
	syncm.bus_subscribe(BUS_NAME, cli_name, bus_server_end)?;
	Ok(bus)
	}

	async fn run_mock_guest(
	network_name: String,
	ep_name: String,
	server_name: String,
	) -> Result<(), Error> {
	// Create an ethertap client and an associated ethernet device.
	let ctx = client::connect_to_service::<NetworkContextMarker>()?;
	let (epm, epm_server_end) = fidl::endpoints::create_proxy::<EndpointManagerMarker>()?;
	ctx.get_endpoint_manager(epm_server_end)?;
	let (netm, netm_server_end) = fidl::endpoints::create_proxy::<NetworkManagerMarker>()?;
	ctx.get_network_manager(netm_server_end)?;

	let ep = epm.get_endpoint(&ep_name).await?.unwrap().into_proxy()?;
	let net = netm.get_network(&network_name).await?.unwrap().into_proxy()?;
	let (fake_ep, fake_ep_server_end) = fidl::endpoints::create_proxy::<FakeEndpointMarker>()?;
	net.create_fake_endpoint(fake_ep_server_end)?;

	let netstack = client::connect_to_service::<NetstackMarker>()?;
	let mut cfg = InterfaceConfig {
	name: "eth-test".to_string(),
	filepath: "[TBD]".to_string(),
	metric: DEFAULT_METRIC,
	};

	let _nicid = match ep.get_device().await? {
	fidl_fuchsia_netemul_network::DeviceConnection::Ethernet(eth_device) => {
	netstack.add_ethernet_device(&format!("/{}", ep_name), &mut cfg, eth_device).await?
	}
	fidl_fuchsia_netemul_network::DeviceConnection::NetworkDevice(netdevice) => {
	todo!("(48860) Support and test for NetworkDevice connections. Got unexpected NetworkDevice {:?}", netdevice)
	}
	};

	// Send a message to the server and expect it to be echoed back.
	let echo_string = String::from("hello");

	let bus = open_bus(&ep_name)?;
	let (success, absent) =
	bus.wait_for_clients(&mut vec![server_name.as_str()].drain(..), 0).await?;
	assert!(success);
	assert_eq!(absent, None);

	fake_ep.write(echo_string.as_bytes()).await.context("write failed")?;

	println!("To Server: {}", echo_string);

	let (data, dropped_frames) = fake_ep.read().await.context("read failed")?;
	assert_eq!(dropped_frames, 0);
	let server_string = str::from_utf8(&data)?;
	assert!(
	echo_string == server_string,
	"Server reply ({}) did not match client message ({})",
	server_string,
	echo_string
	);
	println!("From Server: {}", server_string);

	Ok(())
	}

	async fn run_echo_server_ethernet(
	ep_name: String,
	eth_dev: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_ethernet::DeviceMarker>,
	) -> Result<(), Error> {
	// Create an EthernetClient to wrap around the Endpoint's ethernet device.
	let vmo = zx::Vmo::create(256 * ethernet::DEFAULT_BUFFER_SIZE as u64)?;

	let eth_proxy = match eth_dev.into_proxy() {
	Ok(proxy) => proxy,
	_ => return Err(format_err!("Could not get ethernet proxy")),
	};

	let mut eth_client =
	ethernet::Client::new(eth_proxy, vmo, ethernet::DEFAULT_BUFFER_SIZE, &ep_name).await?;

	eth_client.start().await?;

	// Listen for a receive event from the client, echo back the client's
	// message, and then exit.
	let mut eth_events = eth_client.get_stream();
	let mut sent_response = false;

	// Before connecting to the message bus to notify the client of the server's existence, poll
	// for events. Buffers will not be allocated until polling is performed so this ensures that
	// there will be buffers to receive the client's message.
	loop {
	match futures::poll!(eth_events.try_next()) {
	Poll::Pending => break,
	Poll::Ready(result) => match result {
	Ok(result) => match result {
	Some(_) => continue,
	None => panic!("event stream produced empty event"),
	},
	Err(e) => panic!("event stream returned an error: {}", e),
	},
	}
	}

	// get on bus to unlock mock_guest part of test
	let _bus = open_bus(&ep_name)?;

	while let Some(event) = eth_events.try_next().await? {
	match event {
	ethernet::Event::Receive(rx, _flags) => {
	if !sent_response {
	let mut data: [u8; 100] = [0; 100];
	let sz = rx.read(&mut data);
	let user_message =
	str::from_utf8(&data[0..sz]).expect("failed to parse string");
	println!("From client: {}", user_message);
	let () = eth_client.send(&data[0..sz]);
	sent_response = true;

	// Start listening for the server's response to be
	// transmitted to the guest.
	eth_client.tx_listen_start().await?;
	} else {
	// The mock guest will not send anything to the server
	// beyond its initial request. After the server has echoed
	// the response, the next received message will be the
	// server's own output since it is listening for its own
	// Tx messages.
	break;
	}
	}
	_ => {
	continue;
	}
	}
	}

	Ok(())
	}

	async fn run_echo_server(ep_name: String) -> Result<(), Error> {
	// Get the Endpoint that was created in the server's environment.
	let netctx = client::connect_to_service::<NetworkContextMarker>()?;
	let (epm, epm_server_end) = fidl::endpoints::create_proxy::<EndpointManagerMarker>()?;
	netctx.get_endpoint_manager(epm_server_end)?;

	let ep = epm.get_endpoint(&ep_name).await?;

	let ep = match ep {
	Some(ep) => ep.into_proxy()?,
	None => return Err(format_err!("Can't find endpoint {}", &ep_name)),
	};

	match ep.get_device().await? {
	fidl_fuchsia_netemul_network::DeviceConnection::Ethernet(e) => {
	run_echo_server_ethernet(ep_name, e).await
	}
	fidl_fuchsia_netemul_network::DeviceConnection::NetworkDevice(netdevice) => {
	todo!("(48860) Support and test for NetworkDevice connections. Got unexpected NetworkDevice {:?}", netdevice)
	}
	}
	}

	#[fasync::run_singlethreaded]
	async fn main() -> Result<(), Error> {
	let opt = Opt::from_args();

	if opt.is_mock_guest {
	if opt.network_name == None \|\| opt.endpoint_name == None \|\| opt.server_name == None {
	return Err(format_err!(
	"Must provide network_name, endpoint_name, and server_name for mock guests"
	));
	}
	run_mock_guest(
	opt.network_name.unwrap(),
	opt.endpoint_name.unwrap(),
	opt.server_name.unwrap(),
	)
	.await?;
	} else if opt.is_server {
	match opt.endpoint_name {
	Some(endpoint_name) => {
	run_echo_server(endpoint_name).await?;
	}
	None => {
	return Err(format_err!("Must provide endpoint_name for server"));
	}
	}
	}
	Ok(())
	}