मैं एक प्रोग्राम लिख रहा हूं जो एसएसएच का उपयोग कर सर्वर पर एक कमांड निष्पादित करता है और आउटपुट प्राप्त करता है।

जो हिस्सा मुझे समझ में नहीं आता वह कोड में कम है।

यदि फ़ंक्शन प्रतीक्षा करता है और फिर एक स्ट्रिंग देता है, तो यह अपेक्षा के अनुरूप काम करता है, लेकिन यदि टीसीपी के साथ काम करता है तो यह बहुत खराब प्रदर्शन करना शुरू कर देता है। मुझे उम्मीद है कि १०० होस्ट पर १०० थ्रेड्स का उपयोग १०० गुना तेज प्रदर्शन करेगा, क्योंकि एक साथ १०० सॉकेट खुलेंगे।

स्लीप संस्करण में, poolThreads को बदलने से निष्पादन का समय सीधे प्रभावित होता है। TCP स्ट्रीम वाले संस्करण में, pool को १०० होस्ट के साथ १ से १०० में बदलना केवल ९० से ६७ तक गति देता है क्योंकि कुछ होस्ट ऑफ़लाइन हैं।

मैंने प्रलेखन पढ़ा, लेकिन मेरी मदद करने के लिए कुछ भी नहीं मिला।

use clap::{App, Arg};
use rayon::prelude::*;
use rayon::ThreadPoolBuilder;
use ssh2::Session;
use std::fmt::Display;
use std::io::prelude::*;
use std::io::{BufReader, Read};
use std::net::{TcpStream, ToSocketAddrs};
use std::thread::sleep;
use std::time::Duration;

fn process_host<A>(hostname: A) -> Result<String, String>
where
    A: ToSocketAddrs + Display,
{
    sleep(Duration::from_secs(1));
    return Ok(hostname.to_string());
    // here is the problem
    // -----------------------------------------------------------
    let tcp = match TcpStream::connect(&hostname) {
        Ok(a) => a,
        Err(e) => {
            return Err(format!("{}:{}", hostname, e).to_string());
        }
    };
    let mut sess = match Session::new() {
        Ok(a) => a,
        Err(e) => {
            // todo logging
            return Err(format!("{}:{}", hostname, e).to_string());
        }
    };
    sess.set_tcp_stream(tcp);
    match sess.handshake() {
        Ok(a) => a,
        Err(e) => {
            return Err(format!("{}:{}", hostname, e).to_string());
        }
    };
    Ok(format!("{}", hostname))
}


fn main() {

    let hosts = vec!["aaaaa:22", "bbbbbbb:22"];
    let pool = ThreadPoolBuilder::new()
        .num_threads(10)
        .build()
        .expect("failed creating pool");
    pool.install(|| {
        hosts
            .par_iter()
            .map(|x| process_host(x))
            .for_each(|x| println!("{:?}", x))
    });
}
0
Vladimir 15 जिंदा 2020, 21:42

1 उत्तर

सबसे बढ़िया उत्तर

ऐसी समस्या को डीबग करने के लिए, आपको विश्लेषण करने की आवश्यकता है, जहां आपका प्रोग्राम अपना समय बर्बाद करता है। वहाँ तरीके हैं: टीसीपी कनेक्शन की रूपरेखा और विश्लेषण।
मैं आपको 2 तरीके सुझाता हूं, क्योंकि यह बहुत आसान है। वायरशार्क के साथ ट्रैफ़िक डंप करें, इसे पोर्ट 22 द्वारा फ़िल्टर करें। इसके बाद, बातचीत का उपयोग करें टैब। यहां आप समय के अनुसार कनेक्शन को सॉर्ट कर सकते हैं, और देख सकते हैं कि एसएसएच कनेक्शन के लिए कोई समय सीमा नहीं होने के कारण वह प्रोग्राम गति नहीं करता है।

0
Vladimir 17 जिंदा 2020, 18:06