Tower Rust: पूर्ण गाइड उदाहरणों के साथ

Tower क्या है और इसकी आवश्यकता क्यों है?

Tower Rust इकोसिस्टम की एक मौलिक लाइब्रेरी है, जो मॉड्यूलर, कम्पोज़ेबल और एसिंक्रोनस नेटवर्क सर्विसेज़ और मिडलवेयर (middleware) बनाने के लिए एब्स्ट्रैक्शन प्रदान करती है। यह कोई तैयार HTTP-फ्रेमवर्क (जैसे Actix-web या Axum) नहीं है, बल्कि उनके लिए एक "बिल्डिंग ब्लॉक" है। उदाहरण के लिए, Axum, Tower के ऊपर बनाया गया है।

Tower का मुख्य विचार Service ट्रेट है, जो एक एसिंक्रोनस फंक्शन है जो अनुरोध (Request) को प्रतिक्रिया (Response) में बदलता है। Tower में Middleware (या "Layer") एक सर्विस को दूसरे सर्विस में लपेटने का तरीका है, जिससे मूल सर्विस कोड में बदलाव किए बिना अतिरिक्त व्यवहार (लॉगिंग, प्रमाणीकरण, टाइम-आउट, लोड बैलेंसिंग आदि) जोड़ा जा सकता है।

इसकी आवश्यकता क्यों है?

• मॉड्यूलरिटी: आप अनुरोध प्रोसेसिंग के जटिल लॉजिक को छोटे, स्वतंत्र, पुन: प्रयोग करने योग्य घटकों (सर्विसेज़ और मिडलवेयर) में विभाजित कर सकते हैं।
• कम्पोज़ेबिलिटी: मिडलवेयर को आसानी से एक-दूसरे के ऊपर परतों (layers) की तरह जोड़ा जा सकता है।
• एसिंक्रोनस: Tower एसिंक्रोनस Rust (tokio, async-std) के साथ काम करने के लिए डिज़ाइन की गई है और futures को सपोर्ट करती है।
• परीक्षण क्षमता: प्रत्येक घटक का अलग-अलग परीक्षण किया जा सकता है।

Tower की स्थापना (Installation)

Tower एक Rust लाइब्रेरी है, इसलिए इसे Cargo पैकेज मैनेजर के माध्यम से स्थापित किया जाता है। अपनी Cargo.toml फ़ाइल में निर्भरता जोड़ें:

[dependencies]
tower = { version = "0.4", features = ["full"] } # "full" सभी सुविधाओं को शामिल करता है
tokio = { version = "1", features = ["full"] } # एसिंक्रोनस रनटाइम के लिए

इसके बाद टर्मिनल में यह कमांड चलाएँ:

cargo build

लाइब्रेरी डाउनलोड हो जाएगी और आपके प्रोजेक्ट के साथ कंपाइल हो जाएगी।

त्वरित शुरुआत: आपकी पहली सर्विस और middleware

चलिए एक सरल सर्विस बनाते हैं जो एक स्ट्रिंग लेती है और उसे अपरकेस में लौटाती है। फिर इसे एक मिडलवेयर में लपेटेंगे जो प्रत्येक अनुरोध को लॉग करता है।

use std::convert::Infallible;
use std::task::{Context, Poll};
use tower::{Service, Layer, ServiceBuilder};
use tower::layer::util::Identity;
use std::future::{Ready, ready};

// 1. अपनी सर्विस को परिभाषित करें
#[derive(Clone)]
struct MyService;

impl<Request> Service<Request> for MyService {
    type Response = String;
    type Error = Infallible;
    type Future = Ready<Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request) -> Self::Future {
        // बस एक स्ट्रिंग लौटाएँ
        ready(Ok(format!("Hello from service! Request: {:?}", std::any::type_name::<Request>())))
    }
}

// 2. लॉगिंग के लिए middleware को परिभाषित करें
#[derive(Clone)]
struct LogMiddleware;

impl<S> Layer<S> for LogMiddleware {
    type Service = LogService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        LogService { inner }
    }
}

#[derive(Clone)]
struct LogService<S> {
    inner: S,
}

impl<S, Request> Service<Request> for LogService<S>
where
    S: Service<Request>,
    S::Future: std::marker::Send,
    Request: std::fmt::Debug,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: Request) -> Self::Future {
        println!("[LOG] Received request: {:?}", req);
        self.inner.call(req)
    }
}

#[tokio::m