89 lines
2.8 KiB
Rust
89 lines
2.8 KiB
Rust
use crate::error::ValidatorError;
|
|
use async_stream::stream;
|
|
use futures::{pin_mut, stream::StreamExt};
|
|
use reqwest::Client;
|
|
use std::time::Instant;
|
|
use tokio::{fs, io::AsyncWriteExt, sync::mpsc};
|
|
|
|
use super::{http_client::client_builder, key_tester::validate_key};
|
|
use crate::adapters::{load_keys, write_keys_txt_file};
|
|
use crate::config::KeyCheckerConfig;
|
|
use crate::types::GeminiKey;
|
|
|
|
pub struct ValidationService {
|
|
config: KeyCheckerConfig,
|
|
client: Client,
|
|
full_url: url::Url,
|
|
}
|
|
|
|
impl ValidationService {
|
|
pub fn new(config: KeyCheckerConfig, client: Client) -> Self {
|
|
let full_url = config.gemini_api_url();
|
|
Self {
|
|
config,
|
|
client,
|
|
full_url,
|
|
}
|
|
}
|
|
|
|
pub async fn validate_keys(&self, keys: Vec<GeminiKey>) -> Result<(), ValidatorError> {
|
|
let start_time = Instant::now();
|
|
|
|
// Create channel for streaming keys from producer to consumer
|
|
let (tx, mut rx) = mpsc::unbounded_channel::<GeminiKey>();
|
|
let stream = stream! {
|
|
while let Some(item) = rx.recv().await {
|
|
yield item;
|
|
}
|
|
};
|
|
|
|
// Spawn producer task to send keys through channel
|
|
tokio::spawn(async move {
|
|
for key in keys {
|
|
if let Err(e) = tx.send(key) {
|
|
eprintln!("Failed to send key: {}", e);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Create stream to validate keys concurrently
|
|
let valid_keys_stream = stream
|
|
.map(|key| validate_key(self.client.clone(), self.full_url.clone(), key))
|
|
.buffer_unordered(self.config.concurrency)
|
|
.filter_map(|result| async { result.ok() });
|
|
pin_mut!(valid_keys_stream);
|
|
|
|
// Open output file for writing valid keys
|
|
let output_file = fs::File::create(&self.config.output_path).await?;
|
|
let mut buffer_writer = tokio::io::BufWriter::new(output_file);
|
|
|
|
// Process validated keys and write to output file
|
|
while let Some(valid_key) = valid_keys_stream.next().await {
|
|
if let Err(e) = write_keys_txt_file(&mut buffer_writer, &valid_key).await {
|
|
eprintln!("Failed to write key to output file: {}", e);
|
|
}
|
|
}
|
|
|
|
// Flush the buffer to ensure all data is written to the file
|
|
buffer_writer.flush().await?;
|
|
|
|
println!("Total Elapsed Time: {:?}", start_time.elapsed());
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
|
|
pub async fn start_validation() -> Result<(), ValidatorError> {
|
|
let config = KeyCheckerConfig::load_config()?;
|
|
|
|
// 加载密钥
|
|
let keys = load_keys(config.input_path.as_path())?;
|
|
|
|
// 构建HTTP客户端
|
|
let client = client_builder(&config)?;
|
|
|
|
// 创建验证服务并启动
|
|
let validation_service = ValidationService::new(config, client);
|
|
validation_service.validate_keys(keys).await
|
|
}
|