micro_rank/exchanges/tests/test.rs

use exchanges::gate_swap_rest::GateSwapRest;
use std::collections::BTreeMap;
use tokio::io::{AsyncReadExt};
use exchanges::kucoin_swap_rest::KucoinSwapRest;
use exchanges::kucoin_swap_ws::{KucoinSwapSubscribeType, KucoinSwapWs, KucoinSwapWsType};
use exchanges::{proxy};
use exchanges::okx_swap_ws::{OkxSwapSubscribeType, OkxSwapWs, OkxSwapWsType};

use std::io::{Read, Write};
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use tokio::sync::mpsc::channel;
use tokio::try_join;
use tracing::{trace};
use tracing::instrument::WithSubscriber;
use exchanges::binance_swap_rest::BinanceSwapRest;
use exchanges::binance_swap_ws::{BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
use exchanges::okx_swap_rest::OkxSwapRest;

#[tokio::test]
async fn test_import() {
    global::log_utils::init_log_with_trace();


    /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
    if proxy::ParsingDetail::http_enable_proxy() {
        trace!("检测有代理配置，配置走代理");
    }


    //获取代理
    // demo_get_http_proxy();

    //币安---深度socket-公共频道订阅
    // demo_pub_ws_ba().await;
    // 币安-rest-获取账户信息
    // demo_rest_ba().await;
    //本次更新成功


    //gate-rest -账户信息
    // demo_rest_gate().await;
    //gate-ws-public-private频道
    // demo_ws_gate().await;


    //kucoin_rest -账户信息
    // demo_rest_kucoin().await;
    //Kucoin-ws--公共频道
    // demo_ws_kucoin_pu().await;
    //Kucoin-ws--私有频道
    // demo_ws_kucoin_pr().await;

    //okx - Business 频道
    // demo_ws_okx_bu().await;
    //okx - public 频道
    // demo_ws_okx_pu().await;
    //okx - rest 频道
    // demo_okx_rest().await;

    // demo_so();


    // let mut ku_ws = KucoinSwapWs::new(false, btree_map.clone(),
    //                                   KucoinWsType::Private, tx).await;
    // ku_ws.set_subscribe(vec![KucoinSubscribeType::PrContractMarketTradeOrdersSys]);
    //
    // let t1 = tokio::spawn(async move {
    //     ku_ws.custom_subscribe(vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
    // });
    //
    // let t2 = tokio::spawn(async move {
    //     let mut stdout = std::io::stdout();
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             writeln!(stdout, "age: {:?}", received).unwrap();
    //         }
    //     }
    // let t01 = tokio::spawn(async move {
    //     loop {
    //         tokio::time::sleep(Duration::from_secs(2)).await;
    //         trace!( "发送-指令: ");
    //     }
    // });
    // let t02 = tokio::spawn(async move {
    //     loop {
    //         tokio::time::sleep(Duration::from_secs(3)).await;
    //         trace!( "接收 -指令: ");
    //     }
    // });
    // try_join!(t01,t02).unwrap();


    // let (mut tx_end, mut rx_end) = channel::<String>(1024);
    // let (mut tx_read, mut rx_read) = channel::<String>(1024);
    // let mut stream = tokio::net::TcpStream::connect("127.0.0.1:8080").await.unwrap();
    // stream.write_all( b"Hello, server!").await.unwrap();
    // stream.flush().await.unwrap();
    // let mutex_stream = Arc::new(Mutex::new(stream));
    //
    // //捕捉用户的主动发送的订阅指令
    // let stream_clone = Arc::clone(&mutex_stream);
    // let t_1 = tokio::spawn(async move {
    //     loop {
    //         tokio::time::sleep(Duration::from_secs(1)).await;
    //         if let Ok(received) = rx_end.try_recv() {
    //             trace!("动态订阅内容： {:?}", received);
    //             let mut stream_lock = stream_clone.lock().await;
    //             // stream_lock.write_all( b"1111!").await.unwrap();
    //             // stream_lock.flush().await.unwrap();
    //
    //             // stream_lock.write_all(b"Hello, server!").await.unwrap();
    //         }
    //     }
    // });
    //
    //
    // //socket数据获取，装入回显通道
    // let stream_clone = Arc::clone(&mutex_stream);
    // let t_2 = tokio::spawn(async move {
    //     // 创建一个用于存储服务器响应的缓冲区
    //     let mut buffer = [0; 512];
    //     loop {
    //         let mut stream_lock = stream_clone.lock().await;
    //         tokio::time::sleep(Duration::from_secs(1)).await;
    //
    //         let _ = match stream_lock.read(&mut buffer).await {
    //             Ok(n) => {
    //                 tokio::time::sleep(Duration::from_secs(1)).await;
    //                 if n == 0 {
    //                     // 没有读取到数据
    //                     trace!("没有数据,主动发送");
    //                 } else {
    //                     // 打印服务器的响应
    //                     trace!("有数据: {}", String::from_utf8_lossy(&buffer[..n]));
    //                     tx_read.send(format!("{}", String::from_utf8_lossy(&buffer[..n]))).await.unwrap()
    //                 }
    //             }
    //             Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
    //                 // 如果读取操作会阻塞，则等待一会儿再试
    //                 trace!("Would block, sleeping会阻碍睡眠??");
    //                 tokio::time::sleep(Duration::from_secs(3)).await;
    //                 continue;
    //             }
    //             Err(e) => {
    //                 trace!("Err:{:?}",e);
    //                 break;
    //             }
    //         };
    //     }
    // });
    //
    //
    // //socket 数据回显
    // let t02 = tokio::spawn(async move {
    //     loop {
    //         tokio::time::sleep(Duration::from_secs(1)).await;
    //         // tx.send("hai!!!".to_string()).await.unwrap();
    //         if let Ok(received) = rx_read.try_recv() {
    //             trace!("拿到 socket 的数据: {:?}", received);
    //         }
    //     }
    // });
    //
    // //模拟用户动态发送
    // let t03 = tokio::spawn(async move {
    //     loop {
    //         tokio::time::sleep(Duration::from_secs(1)).await;
    //         tx_end.send("这里是 动态订阅".to_string()).await.unwrap();
    //     }
    // });
    //
    // try_join!(t_1,t_2,t02,t03).unwrap();
}


async fn demo_okx_rest() {
    // let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    // btree_map.insert("access_key".to_string(), "".to_string());
    // btree_map.insert("secret_key".to_string(), "".to_string());
    // btree_map.insert("pass_key".to_string(), "".to_string());
    //
    // let mut okx_rest = OkxSwapRest::new(false, btree_map);
    // let res_data = okx_rest.get_account("BTC".to_string()).await;
    // trace!("okx_rest-rest - get_account- {:?}", res_data);
}

async fn demo_ws_gate() {}


fn demo_so() {
    // 代理服务器地址和端口
    // let proxy_address = "127.0.0.1:7890";
    // // 目标服务器地址和端口
    // let target_address = "wss://ws.okx.com:8443/ws/v5/public";
    //
    //   // 建立与代理服务器的连接
    //   let mut proxy_stream = TcpStream::connect(proxy_address).expect("Failed to connect to proxy");
    //
    //   // 发送代理请求
    //   let request = format!("CONNECT {}\r\n\r\n", target_address);
    //   proxy_stream.write_all(request.as_bytes()).expect("Failed to send proxy request");
    //
    //   // 读取代理响应
    //   let mut response = String::new();
    //   proxy_stream.read_to_string(&mut response).expect("Failed to read proxy response");
    //
    //   // 检查代理响应是否成功
    //   if !response.contains("200 Connection established") {
    //       trace!("Proxy connection failed: {}", response);
    //   }
    //
    //   // 从代理连接中获取原始 TCP 流
    //   let mut tcp_stream = std::mem::ManuallyDrop::new(proxy_stream);
    //
    //   // 现在你可以使用 `tcp_stream` 来进行与目标服务器的通信
    //   // 例如，发送和接收数据
    //   // tcp_stream.write_all(b"Hello, server!").expect("Failed to send data");
    //
    //   thread::spawn(move || {
    //       loop {
    //           let mut buffer = [0u8; 1024]; // 用于存储读取的数据的缓冲区
    //           let bytes_read = tcp_stream.read(&mut buffer).expect("Failed to read data");
    //
    //           // 将读取的数据转换为字符串并打印
    //           if let Ok(data) = std::str::from_utf8(&buffer[..bytes_read]) {
    //               trace!("Received data: {}", data);
    //           } else {
    //               trace!("Received data contains non-UTF8 characters");
    //           }
    //       }
    //
    //   });
    //
    //   // 最后记得手动释放套接字
    //   // 注意：不要调用 `drop(tcp_stream)`，因为我们使用了 `ManuallyDrop` 来避免自动释放
    //   unsafe {
    //       std::mem::ManuallyDrop::drop(&mut tcp_stream);
    //   }
}


async fn demo_ws_okx_pu() {

    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
    // let (tx, mut rx) = channel(1024);
    // let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Public, tx);
    // ku_ws.set_subscribe(vec![OkxSubscribeType::PuIndexTickers]);
    // let t1 = tokio::spawn(async move {
    //     ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]).await;
    // });
    // let t2 = tokio::spawn(async move {
    //     let mut stdout = std::io::stdout();
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             writeln!(stdout, "age: {:?}", received).unwrap();
    //         }
    //     }
    // });
    // try_join!(t1,t2).unwrap();
}

async fn demo_ws_okx_bu() {
    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
    // let (tx, mut rx) = channel(1024);
    // let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Business, tx);
    // ku_ws.set_subscribe(vec![OkxSubscribeType::BuIndexCandle30m]);
    // let t1 = tokio::spawn(async move {
    //     ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]).await;
    // });
    // let t2 = tokio::spawn(async move {
    //     let mut stdout = std::io::stdout();
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             writeln!(stdout, "age: {:?}", received).unwrap();
    //         }
    //     }
    // });
    // try_join!(t1,t2).unwrap();
}

async fn demo_ws_kucoin_pr() {
    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
    // let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    // btree_map.insert("access_key".to_string(), "".to_string());
    // btree_map.insert("secret_key".to_string(), "".to_string());
    // btree_map.insert("pass_key".to_string(), "".to_string());
    // trace!("----------------------btree_map{:?}", btree_map.clone());
    // let (tx, mut rx) = channel(1024);
    // let mut ku_ws = KucoinSwapWs::new(false, btree_map.clone(),
    //                                   KucoinWsType::Private, tx).await;
    // ku_ws.set_subscribe(vec![KucoinSubscribeType::PrContractMarketTradeOrdersSys]);
    //
    // let t1 = tokio::spawn(async move {
    //     ku_ws.custom_subscribe(is_shutdown_arc, vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
    // });
    //
    // let t2 = tokio::spawn(async move {
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             trace!( "age: {:?}", received);
    //         }
    //     }
    // });
    //
    // try_join!(t1,t2).unwrap();
}

async fn demo_ws_kucoin_pu() {
    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
    // let (tx, mut rx) = channel(1024);
    // let mut ku_ws = KucoinSwapWs::new(false, btree_map, KucoinWsType::Public, tx).await;
    // ku_ws.set_subscribe(vec![
    //     KucoinSubscribeType::PuContractMarketLevel2Depth50,
    //     KucoinSubscribeType::PuContractMarkettickerV2,
    // ]);
    //
    // let t1 = tokio::spawn(async move {
    //     ku_ws.custom_subscribe(is_shutdown_arc, vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
    // });
    // let t2 = tokio::spawn(async move {
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             trace!("age: {:?}", received);
    //         }
    //     }
    // });
    //
    // try_join!(t1,t2).unwrap();
}

async fn demo_rest_kucoin() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());
    btree_map.insert("pass_key".to_string(), "".to_string());

    let mut kucoin_exc = KucoinSwapRest::new(false, btree_map);
    // let res_data = kucoin_exc.get_server_time().await;
    // trace!("kucoin_exc-rest - get_server_time- {:?}", res_data);
    // trace!("kucoin_exc-rest-get_delays{:?}", kucoin_exc.get_delays() );
    // trace!("kucoin_exc-rest -get_avg_delay{:?}", kucoin_exc.get_avg_delay());
    // let res_data = kucoin_exc.get_account("USDT".to_string()).await;
    // trace!("kucoin_exc-rest - get_account- {:?}", res_data);
    // let res_data = kucoin_exc.get_position("XBT1USDM".to_string()).await;
    // trace!("kucoin_exc-rest - get_position- {:?}", res_data);
    // let res_data = kucoin_exc.get_market_details().await;
    // trace!("kucoin_exc-rest - get_market_details- {:?}", res_data);
    // let res_data = kucoin_exc.get_ticker("ROSEUSDTM".to_string()).await;
    // trace!("kucoin_exc-rest - get_ticker- {:?}", res_data);
    let res_data = kucoin_exc.get_orders("".to_string(),
                                         "".to_string()).await;
    trace!("kucoin_exc-rest - get_orders- {:?}", res_data);
    // let res_data = kucoin_exc.get_positions("USDT".to_string()).await;
    // trace!("kucoin_exc-rest - get_positions- {:?}", res_data);
    // let res_data = kucoin_exc.get_orders_details("111".to_string(), "".to_string()).await;
    // trace!("kucoin_exc-rest - get_orders_details- {:?}", res_data);
    // let res_data = kucoin_exc.swap_bazaar_order(
    //     "cs_202309111808".to_string(),
    //     "ROSEUSDTM".to_string(),
    //     "pd".to_string(),
    //     1,
    //     "10".to_string(),
    //     "0.03856".to_string(),
    //     "limit".to_string(),
    // ).await;
    // trace!("kucoin_exc-rest - swap_bazaar_order- {:?}
    // let res_data = kucoin_exc.cancel_order("".to_string(), "999999".to_string()).await;
    // trace!("kucoin_exc-rest - cancel_order- {:?}", res_data);
    // let res_data = kucoin_exc.get_public_token().await;
    // trace!("kucoin_exc-rest - get_public_token- {:?}", res_data);
}

async fn demo_rest_gate() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());

    let mut gate_exc = GateSwapRest::new(false, btree_map);
    let res_data = gate_exc.get_account("usdt".to_string()).await;
    trace!("gate-rest -账户信息{:?}", res_data);
    trace!("gate-rest -get_delays{:?}", gate_exc.get_delays() );
    trace!("gate-rest -get_avg_delay{:?}", gate_exc.get_avg_delay());
    // let res_data = gate_exc.get_position("usdt".to_string(), "CYBER_USDT".to_string()).await;
    // trace!("gate-rest -持仓信息{:?}", res_data);
    // let res_data = gate_exc.get_ticker("usdt".to_string()).await;
    // trace!("gate-rest -ticker{:?}", res_data);
    // let res_data = gate_exc.get_server_time().await;
    // trace!("gate-rest -get_server_time{:?}", res_data);
    // let res_data = gate_exc.get_user_position("usdt".to_string()).await;
    // trace!("gate-rest -get_server_time{:?}", res_data);
    // let res_data = gate_exc.get_order_details("usdt".to_string(), "11335522".to_string()).await;
    // trace!("gate-rest -get_order_details{:?}", res_data);
    // let res_data = gate_exc.get_orders("usd1t".to_string(), "open".to_string()).await;
    // trace!("gate-rest -get_orders{:?}", res_data);
    // let params = serde_json::json!({
    //         "contract":"CYBER_USDT",
    //         "size":-1,
    //         "price":"0",
    //         "tif":"ioc",
    //      });
    // let res_data = gate_exc.take_order("usdt".to_string(), params).await;
    // trace!("gate-rest -get_orders{:?}", res_data);
    // let res_data = gate_exc.setting_dual_mode("usdt".to_string(), true).await;
    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.setting_dual_leverage("usdt".to_string(),
    //                                               "CYBER_USDT".to_string(),
    //                                               "20".to_string(),
    // ).await;
    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.wallet_transfers("usdt".to_string(),
    //                                               "CYBER_USDT".to_string(),
    //                                               "20".to_string(),
    // ).await;
    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.cancel_order("usdt".to_string(),
    //                                      "12345".to_string(),
    // ).await;
    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
    // let res_data = gate_exc.cancel_orders("usdt".to_string(),
    //                                      "CYBER_USDT".to_string(),
    // ).await;
    // trace!("gate-rest -cancel_orders{:?}", res_data);
    // let res_data = gate_exc.order(
    //     "usdt".to_string(),
    //     "long".to_string(),
    //     "buy".to_string(),
    //     "ROSE_USDT".to_string(),
    //     1,
    //     "0.03888".to_string(),
    //     "t-my-custom-id-001".to_string(),
    // ).await;
    // trace!("gate-rest -order{:?}", res_data);


    // let res_data = gate_exc.my_trades("usdt".to_string()).await;
    // trace!("gate-rest -my_trades{:?}", res_data);
    let res_data = gate_exc.account_book("usdt".to_string()).await;
    trace!("gate-rest -account_book{:?}", res_data);
}

async fn demo_rest_ba() {
    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
    btree_map.insert("access_key".to_string(), "".to_string());
    btree_map.insert("secret_key".to_string(), "".to_string());

    // let ba_exc = BinanceUsdtSwapRest::new(false, btree_map);
    // let res_data = ba_exc.get_account().await;
    let mut ba_exc = BinanceSwapRest::new(false, btree_map);
    // let res_data = ba_exc.get_server_time().await;
    // trace!("币安-rest - get_server_time{:?}", res_data);
    // let res_data = ba_exc.get_exchange_info().await;
    // trace!("币安-restget_ get_exchange_info{:?}", res_data);


    let res_data = ba_exc.get_account().await;
    trace!("币安-rest-获取账户信息{:?}", res_data);
    // trace!("币安-rest- -get_delays{:?}", ba_exc.get_delays() );
    // trace!("币安-rest--get_avg_delay{:?}", ba_exc.get_avg_delay());

    // let res_data = ba_exc.get_order("BTCUSDT".to_string(), 131, "".to_string()).await;
    // trace!("币安-rest--get_order{:?}", res_data);
    // let res_data = ba_exc.get_open_orders("BTCUSDT".to_string()).await;
    // trace!("币安-rest--get_open_orders{:?}", res_data);
    // let timestamp_start = chrono::Utc::now().timestamp_millis() - 60 * 100 * 1000;
    // let timestamp_end = chrono::Utc::now().timestamp_millis() +  60 * 100 * 1000;
    // let res_data = ba_exc.get_all_orders("BTCUSDT".to_string(), 1000, timestamp_start, timestamp_end).await;
    // trace!("币安-rest--get_all_orders{:?}", res_data);
    // let res_data = ba_exc.get_book_ticker("BTCUSDT".to_string()).await;
    // trace!("币安-rest--get_book_ticker{:?}", res_data);
    // let res_data = ba_exc.get_position_risk("BTCUS1DT".to_string()).await;
    // trace!("币安-rest--get_position_risk{:?}", res_data);
    // let res_data = ba_exc.change_pos_side(true).await;
    // trace!("币安-rest--change_pos_side{:?}", res_data);
    // let res_data = ba_exc.cancel_order("BTCUSDT".to_string(), 3312331, "".to_string()).await;
    // trace!("币安-rest--cancel_order{:?}", res_data);
}

async fn demo_pub_ws_ba() {
    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
    // let (tx, mut rx) = channel(1024);
    // let mut binance_ws = BinanceSwapWs::new(false, btree_map, BinanceWsType::PublicAndPrivate, tx);
    // binance_ws.set_subscribe(vec![
    //     BinanceSubscribeType::PuAggTrade,
    //     BinanceSubscribeType::PuDepth20levels100ms,
    //     BinanceSubscribeType::PuBookTicker,
    // ]);
    // let t1 = tokio::spawn(async move {
    //     binance_ws.custom_subscribe(is_shutdown_arc,vec!["BTCUSDT".to_string()]).await;
    // });
    // let t2 = tokio::spawn(async move {
    //     loop {
    //         if let Ok(received) = rx.try_recv() {
    //             trace!( "age: {:?}", received);
    //         }
    //     }
    // });
    // try_join!(t1,t2).unwrap();
}

fn demo_get_http_proxy() {
    //代理地址
    let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
    trace!("----代理信息：{:?}", parsing_detail);
}


// /*********************web服务*/
// fn demo_http() {
//     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
//     for stream in listener.incoming() {
//         let stream = stream.unwrap();
//
//         handle_connection(TcpStream::try_from(stream).unwrap());
//     }
// }
//
//
// fn handle_connection(mut stream: TcpStream) {
//     let buf_reader = BufReader::new(&mut stream);
//     let http_request: Vec<_> = buf_reader
//         .lines()
//         .map(|result| result.unwrap())
//         .take_while(|line| !line.is_empty())
//         .collect();
//     trace!("Request: {:#?}", http_request);
//     trace!("Request2: {:#?}", http_request[0]);
//     trace!("Request3: {:#?}", http_request[1]);
//
//     let (status_line, filename) = if http_request[0] == "GET / HTTP/1.1" {
//         ("HTTP/1.1 200 OK", "hello.html")
//     } else {
//         ("HTTP/1.1 404 NOT FOUND", "404.html")
//     };
//
//     let status_line = "HTTP/1.1 200 OK";
//     let contents = fs::read_to_string("src/404.html").unwrap();
//     let length = contents.len();
//
//     let response =
//         format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
//     // let response = "HTTP/1.1 200 OK\r\n\r\nccccc";
//
//     stream.write_all(response.as_bytes()).unwrap();
// }