build(deps): bump project dependencies (#62)

- [x] update cargo dependencies;

Cargo.toml

@@ -1,17 +1,19 @@
 [package]
 name = "rust-workspace"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 colored = "2.1.0"
-hyper = { version = "0.14", features = ["full"] }
+hyper = { version = "1.2.0", features = ["full"] }
+hyper-util = { version = "0.1.3", features = ["full"] }
+http-body-util = "0.1.1"
 tokio = { version = "1.36.0", features = ["full"] }
 meval = "0.2"
 rand = "0.8.5"
-sysinfo = "0.30.6"
+sysinfo = "0.30.7"
 # ML Packages for Model Training
 linfa = "0.7.0"
 linfa-logistic = { version = "0.7.0", features = ["serde"] }

src/open_weather/mod.rs

@@ -1,11 +1,14 @@
 //! Open weather module.
 
 use colored::Colorize;
-use hyper::{body::Buf, Client, Uri};
+use http_body_util::{BodyExt, Empty};
+use hyper::{body::Bytes, Request, Uri};
+use hyper_util::rt::TokioIo;
 use std::{
     env::args,
     io::{self, Write},
 };
+use tokio::net::TcpStream;
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
@@ -139,9 +142,7 @@ impl OpenWeather {
 
     /// Weather data request logic.
     async fn weather_request(&mut self, city: &str, api_key: &str) -> Result<()> {
-        let client = Client::new();
-
-        let mut uri_with_params = String::from("http:///api.openweathermap.org/data/2.5/weather");
+        let mut uri_with_params = String::from("http://api.openweathermap.org/data/2.5/weather");
         uri_with_params.push_str("?q=");
         uri_with_params.push_str(city);
         uri_with_params.push_str("&appid=");
@@ -151,13 +152,40 @@ impl OpenWeather {
 
         let uri = uri_with_params.as_str().parse::<Uri>()?;
 
-        let res = client.get(uri).await?;
+        let host = uri.host().expect("uri has no host");
+        let port = uri.port_u16().unwrap_or(80);
+        let addr = format!("{}:{}", host, port);
+        let stream = TcpStream::connect(addr).await?;
+        let io = TokioIo::new(stream);
+
+        let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await?;
+        tokio::task::spawn(async move {
+            if let Err(err) = conn.await {
+                println!("Connection failed: {:?}", err);
+            }
+        });
+
+        let authority = uri.authority().unwrap().clone();
 
-        println!("{}: {}", "Response".green(), res.status());
-        println!("{}: {:#?}\n", "Headers".green(), res.headers());
+        let path = uri.path();
+        let req = Request::builder()
+            .uri(path)
+            .header(hyper::header::HOST, authority.as_str())
+            .body(Empty::<Bytes>::new())?;
 
-        let body = hyper::body::aggregate(res).await?;
-        io::stdout().write_all(body.chunk())?;
+        let mut res = sender.send_request(req).await?;
+
+        println!("Response: {}", res.status());
+        println!("Headers: {:#?}\n", res.headers());
+
+        // Stream the body, writing each chunk to stdout as we get it
+        // (instead of buffering and printing at the end).
+        while let Some(next) = res.frame().await {
+            let frame = next?;
+            if let Some(chunk) = frame.data_ref() {
+                io::stdout().write_all(chunk)?;
+            }
+        }
 
         println!("\n\n{}", "Done!".green().bold());