fix: update example

PrivateRookie · Nov 6, 2023 · d6c0870 · d6c0870
1 parent ac8fcd5
commit d6c0870
Show file tree

Hide file tree

Showing 7 changed files with 111 additions and 308 deletions.
diff --git a/examples/autobahn_async_client.rs b/examples/autobahn_async_client.rs
@@ -5,32 +5,29 @@ use ws_tool::{
     codec::{AsyncFrameCodec, AsyncStringCodec},
     errors::WsError,
     frame::OpCode,
-    ClientBuilder,
+    ClientConfig,
 };
 
 const AGENT: &str = "async-client";
 
 async fn get_case_count() -> Result<usize, WsError> {
-    let mut client = ClientBuilder::new()
-        .async_connect(
-            "ws://localhost:9002/getCaseCount".parse().unwrap(),
+    let mut client = ClientConfig::default()
+        .async_connect_with(
+            "ws://localhost:9002/getCaseCount",
             AsyncStringCodec::check_fn,
         )
         .await
         .unwrap();
-    let msg = client.receive().await.unwrap().data.parse().unwrap();
-    client.receive().await.unwrap();
-    // send_close(&mut client, 1001, "".to_string()).unwrap();
+    let msg = client.receive().await.unwrap();
+    let msg = msg.data.parse().unwrap();
     Ok(msg)
 }
 
 async fn run_test(case: usize) -> Result<(), WsError> {
     info!("running test case {}", case);
-    let url: http::Uri = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT)
-        .parse()
-        .unwrap();
-    let (mut read, mut write) = ClientBuilder::new()
-        .async_connect(url, AsyncFrameCodec::check_fn)
+    let url = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT);
+    let (mut read, mut write) = ClientConfig::default()
+        .async_connect_with(url, AsyncFrameCodec::check_fn)
         .await
         .unwrap()
         .split();
@@ -79,14 +76,9 @@ async fn run_test(case: usize) -> Result<(), WsError> {
 }
 
 async fn update_report() -> Result<(), WsError> {
-    let url: http::Uri = format!("ws://localhost:9002/updateReports?agent={}", AGENT)
-        .parse()
-        .unwrap();
-    let mut client = ClientBuilder::new()
-        .async_connect(url, AsyncStringCodec::check_fn)
-        .await
-        .unwrap();
-    client.send((1000u16, String::new())).await.map(|_| ())
+    let url = format!("ws://localhost:9002/updateReports?agent={}", AGENT);
+    let mut client = ClientConfig::default().async_connect(url).await.unwrap();
+    client.close(1000u16, &[]).await
 }
 
 #[tokio::main]

diff --git a/examples/autobahn_async_deflate_client.rs b/examples/autobahn_async_deflate_client.rs
@@ -3,24 +3,24 @@ use rand::random;
 use tracing::*;
 use tracing_subscriber::util::SubscriberInitExt;
 use ws_tool::{
-    codec::{AsyncDeflateCodec, AsyncStringCodec, PMDConfig, WindowBit},
+    codec::{AsyncStringCodec, WindowBit},
     errors::WsError,
     frame::{OpCode, OwnedFrame},
-    ClientBuilder,
+    ClientConfig,
 };
 
 const AGENT: &str = "async-deflate-client";
 
 async fn get_case_count() -> Result<usize, WsError> {
-    let mut client = ClientBuilder::new()
-        .async_connect(
-            "ws://localhost:9002/getCaseCount".parse().unwrap(),
+    let mut client = ClientConfig::default()
+        .async_connect_with(
+            "ws://localhost:9002/getCaseCount",
             AsyncStringCodec::check_fn,
         )
         .await
         .unwrap();
-    let msg = client.receive().await.unwrap().data.parse().unwrap();
-    client.receive().await.unwrap();
+    let msg = client.receive().await.unwrap();
+    let msg = msg.data.parse().unwrap();
     Ok(msg)
 }
 
@@ -30,25 +30,16 @@ fn mask_key() -> [u8; 4] {
 
 async fn run_test(case: usize) -> Result<(), WsError> {
     info!("running test case {}", case);
-    let url: http::Uri = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT)
-        .parse()
-        .unwrap();
-    let config = PMDConfig {
-        server_max_window_bits: WindowBit::Nine,
-        client_max_window_bits: WindowBit::Nine,
-        ..PMDConfig::default()
-    };
-    let (mut read, mut write) = match ClientBuilder::new()
-        .extension(config.ext_string())
-        .async_connect(url, AsyncDeflateCodec::check_fn)
-        .await
-    {
-        Ok(client) => client.split(),
-        Err(e) => {
-            tracing::error!("{e}");
-            return Ok(());
-        }
-    };
+    let url = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT);
+    let (mut read, mut write) = ClientConfig {
+        window: Some(WindowBit::Nine),
+        ..Default::default()
+    }
+    .async_connect(url)
+    .await
+    .unwrap()
+    .split();
+
     let now = std::time::Instant::now();
     loop {
         match read.receive().await {
@@ -100,14 +91,9 @@ async fn run_test(case: usize) -> Result<(), WsError> {
 }
 
 async fn update_report() -> Result<(), WsError> {
-    let url: http::Uri = format!("ws://localhost:9002/updateReports?agent={}", AGENT)
-        .parse()
-        .unwrap();
-    let mut client = ClientBuilder::new()
-        .async_connect(url, AsyncStringCodec::check_fn)
-        .await
-        .unwrap();
-    client.send((1000u16, String::new())).await.map(|_| ())
+    let url = format!("ws://localhost:9002/updateReports?agent={}", AGENT);
+    let mut client = ClientConfig::default().async_connect(url).await.unwrap();
+    client.close(1000u16, &[]).await
 }
 
 #[tokio::main]

diff --git a/examples/autobahn_client.rs b/examples/autobahn_client.rs
@@ -5,28 +5,25 @@ use ws_tool::{
     codec::{FrameCodec, StringCodec},
     errors::WsError,
     frame::OpCode,
-    ClientBuilder,
+    ClientConfig,
 };
 
 const AGENT: &str = "client";
 
 fn get_case_count() -> Result<usize, WsError> {
     let uri = "ws://localhost:9002/getCaseCount";
-    let mut client = ClientBuilder::new()
-        .connect(uri.parse().unwrap(), StringCodec::check_fn)
+    let mut client = ClientConfig::default()
+        .connect_with(uri, StringCodec::check_fn)
         .unwrap();
     let msg = client.receive().unwrap().data.parse().unwrap();
-    client.receive().unwrap();
     Ok(msg)
 }
 
 fn run_test(case: usize) -> Result<(), WsError> {
     info!("running test case {}", case);
-    let url: http::Uri = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT)
-        .parse()
-        .unwrap();
-    let (mut read, mut write) = ClientBuilder::new()
-        .connect(url, FrameCodec::check_fn)
+    let url = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT);
+    let (mut read, mut write) = ClientConfig::default()
+        .connect_with(url, FrameCodec::check_fn)
         .unwrap()
         .split();
     loop {
@@ -76,13 +73,9 @@ fn run_test(case: usize) -> Result<(), WsError> {
 }
 
 fn update_report() -> Result<(), WsError> {
-    let url: http::Uri = format!("ws://localhost:9002/updateReports?agent={}", AGENT)
-        .parse()
-        .unwrap();
-    let mut client = ClientBuilder::new()
-        .connect(url, StringCodec::check_fn)
-        .unwrap();
-    client.send((1000u16, String::new())).map(|_| ())
+    let url = format!("ws://localhost:9002/updateReports?agent={}", AGENT);
+    let mut client = ClientConfig::default().connect(url).unwrap();
+    client.close(1000u16, &[]).map(|_| ())
 }
 
 fn main() -> Result<(), ()> {

diff --git a/examples/autobahn_deflate_client.rs b/examples/autobahn_deflate_client.rs
@@ -2,23 +2,20 @@ use rand::random;
 use tracing::*;
 use tracing_subscriber::util::SubscriberInitExt;
 use ws_tool::{
-    codec::{DeflateCodec, PMDConfig, StringCodec, WindowBit},
+    codec::{StringCodec, WindowBit},
     errors::WsError,
     frame::{OpCode, OwnedFrame},
-    ClientBuilder,
+    ClientConfig,
 };
 
 const AGENT: &str = "deflate-client";
 
 fn get_case_count() -> Result<usize, WsError> {
-    let mut client = ClientBuilder::new()
-        .connect(
-            "ws://localhost:9002/getCaseCount".parse().unwrap(),
-            StringCodec::check_fn,
-        )
+    let uri = "ws://localhost:9002/getCaseCount";
+    let mut client = ClientConfig::default()
+        .connect_with(uri, StringCodec::check_fn)
         .unwrap();
     let msg = client.receive().unwrap().data.parse().unwrap();
-    client.receive().unwrap();
     Ok(msg)
 }
 
@@ -28,24 +25,14 @@ fn mask_key() -> [u8; 4] {
 
 fn run_test(case: usize) -> Result<(), WsError> {
     info!("running test case {}", case);
-    let url: http::Uri = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT)
-        .parse()
-        .unwrap();
-    let config = PMDConfig {
-        server_max_window_bits: WindowBit::Nine,
-        client_max_window_bits: WindowBit::Nine,
-        ..PMDConfig::default()
-    };
-    let (mut read, mut write) = match ClientBuilder::new()
-        .extension(config.ext_string())
-        .connect(url, DeflateCodec::check_fn)
-    {
-        Ok(client) => client.split(),
-        Err(e) => {
-            tracing::error!("{e}");
-            return Ok(());
-        }
-    };
+    let url = format!("ws://localhost:9002/runCase?case={}&agent={}", case, AGENT);
+    let (mut read, mut write) = ClientConfig {
+        window: Some(WindowBit::Nine),
+        ..Default::default()
+    }
+    .connect(url)
+    .unwrap()
+    .split();
     let now = std::time::Instant::now();
     loop {
         match read.receive() {
@@ -95,13 +82,9 @@ fn run_test(case: usize) -> Result<(), WsError> {
 }
 
 fn update_report() -> Result<(), WsError> {
-    let url: http::Uri = format!("ws://localhost:9002/updateReports?agent={}", AGENT)
-        .parse()
-        .unwrap();
-    let mut client = ClientBuilder::new()
-        .connect(url, StringCodec::check_fn)
-        .unwrap();
-    client.send((1000u16, String::new())).map(|_| ())
+    let url = format!("ws://localhost:9002/updateReports?agent={}", AGENT);
+    let mut client = ClientConfig::default().connect(url).unwrap();
+    client.close(1000u16, &[]).map(|_| ())
 }
 
 fn main() -> Result<(), ()> {

diff --git a/examples/deflate_client.rs b/examples/deflate_client.rs
diff --git a/examples/deflate_server.rs b/examples/deflate_server.rs