6个Rust网络编程库包

use socket2::{Socket, Domain, Type, Protocol}; 
 
// Create a new TCP socket in the IPv4 domain 
let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP))?; 
// This line creates a TCP socket for IPv4 communication.

use std::time::Duration; 
 
// Set a read timeout of 10 seconds 
socket.set_read_timeout(Some(Duration::from_secs(10)))?; 
// Set a write timeout of 10 seconds 
socket.set_write_timeout(Some(Duration::from_secs(10)))?; 
// 如果读取或写入操作的时间超过 10 秒，这些线路将配置套接字超时.

use ipnet::Ipv4Net; 
 
// Parse a CIDR string into an Ipv4Net type 
let network = "192.168.1.0/24".parse::<Ipv4Net>()?; 
// This line creates an IPv4 network representing the subnet 192.168.1.0/24.

use std::net::Ipv4Addr; 
 
// Check if an IP address belongs to the defined network 
let addr = Ipv4Addr::new(192, 168, 1, 10); 
let is_member = network.contains(&addr); 
// This code checks whether the IP address 192.168.1.10 is part of the previously defined network.

// Iterate over all IP addresses in the network 
for ip in network.hosts() { 
    println!("{}", ip); 
} 
// This loop iterates through and prints all host addresses in the 192.168.1.0/24 network.

syntax = "proto3"; 
 
package myapp; 
service MyService { 
  rpc SayHello (HelloRequest) returns (HelloReply); 
} 
message HelloRequest { 
  string name = 1; 
} 
message HelloReply { 
  string message = 1; 
}

fn main() -> Result<(), Box<dyn std::error::Error>> { 
    tonic_build::compile_protos("proto/myapp.proto")?; 
    Ok(()) 
} 
// This will generate Rust code for the defined service and messages when building the project.

use tower_http::trace::TraceLayer; 
use tower::ServiceBuilder; 
 
// Create a service stack with the TraceLayer for logging 
let service = ServiceBuilder::new() 
    .layer(TraceLayer::new_for_http()) 
    .service(my_http_service); 
// This adds HTTP request and response logging to the service.

use tower_http::compression::CompressionLayer; 
 
// Add compression middleware to the service stack 
let service = ServiceBuilder::new() 
    .layer(CompressionLayer::new()) 
    .service(my_http_service); 
// This enables response compression for supported formats like gzip or brotli.

use hyper::Client; 
use hyper_rustls::HttpsConnector; 
 
// Create a TLS-enabled HTTPS connector 
let https = HttpsConnector::with_native_roots(); 
let client = Client::builder().build::<_, hyper::Body>(https); 
// This code sets up an HTTPS client using Hyper-rustls, leveraging Rustls for TLS.

use hyper::server::Server; 
use hyper_rustls::TlsAcceptor; 
use tokio_rustls::TlsAcceptor; 
 
// Assume 'config' is your Rustls server configuration 
let tls_acceptor = TlsAcceptor::from(Arc::new(config)); 
let server = Server::bind(&addr).serve(make_svc); 
// Here, a secure HTTP server is set up using Hyper with Rustls for TLS.

use matchit::Router; 
 
let mut router = Router::new(); 
// Initialize a new router for URL matching.

router.insert("/user/:name", "user_profile")?; 
// Adds a route for user profiles, where ":name" is a dynamic segment.

let matched = router.at("/user/john_doe").unwrap(); 
assert_eq!(matched.params["name"], "john_doe"); 
// Matches a URL to the defined route, extracting the dynamic "name" parameter.