as-rust/src/main.rs

mod server;

use std::collections::BTreeMap;
use std::io::Error;
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::{mpsc, Mutex};
use tokio::try_join;
use tracing::{error, info};
use exchanges::gate_swap_rest::GateSwapRest;
use standard::exchange::ExchangeEnum::GateSwap;
use standard::Order;
use strategy::model::OrderInfo;
use strategy::params::Params;
use strategy::{exchange_disguise, quant};
use strategy::quant::Quant;

#[tokio::main]
async fn main() {
    // 获取本地配置
    let params = Params::new("config.toml").unwrap();

    // 日志级别配置
    let tracing_log_level = tracing::Level::from_str(params.log_level.as_str()).unwrap();
    global::log_utils::final_init(tracing_log_level);

    info!(?params);
    info!(?tracing_log_level);

    let mut exchange_params:BTreeMap<String, String> = BTreeMap::new();
    exchange_params.insert("access_key".to_string(), params.access_key.clone());
    exchange_params.insert("secret_key".to_string(), params.secret_key.clone());

    let (order_sender, mut order_receiver) = mpsc::channel::<Order>(100);
    let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);

    let mut quant_obj = Quant::new(GateSwap, params.clone(), exchange_params.clone(), order_sender.clone(), error_sender.clone()).await;
    let trade_name = quant_obj.trade_name.clone();
    let mut quant_arc = Arc::new(Mutex::new(quant_obj));

    info!("quant初始化……");
    quant_arc.lock().await.before_trade().await;
    let ref_name = quant_arc.lock().await.ref_name[0].clone();
    // 参考交易所
    exchange_disguise::run_reference_exchange(params.ref_exchange.get(0).unwrap().clone(), quant_arc.clone(), ref_name, params.ref_pair.clone(), exchange_params.clone()).await;
    // 交易交易所
    exchange_disguise::run_transactional_exchange(params.exchange, quant_arc.clone(), trade_name, vec![params.pair.clone()], exchange_params.clone()).await;
    // 启动定期触发的系统逻辑
    quant::on_timer(quant_arc.clone());
    // 启动策略逻辑
    quant::run_strategy(quant_arc.clone());

    info!("quant初始化完成。");

    let order_handler_quant_arc = quant_arc.clone();
    let order_handler_thread = tokio::spawn(async move {
        loop {
            tokio::time::sleep(Duration::from_millis(1)).await;

            match order_receiver.recv().await {
                Some(order) => {
                    {
                        let mut quant = order_handler_quant_arc.lock().await;

                        let mut order_info = OrderInfo {
                            symbol: "".to_string(),
                            amount: order.amount.abs(),
                            side: "".to_string(),
                            price: order.price,
                            client_id: order.custom_id,
                            filled_price: order.avg_price,
                            filled: order.deal_amount.abs(),
                            order_id: order.id,
                            local_time: 0,
                            create_time: 0,
                            status: order.status,
                            fee: Default::default(),
                        };

                        quant.update_local_order(order_info.clone());
                    }
                },
                None => {
                    error!("Order channel has been closed!");
                }
            }
        }
    });

    // let error_handler_quant_arc = quant_arc.clone();
    let error_handler_thread = tokio::spawn(async move {
        loop {
            tokio::time::sleep(Duration::from_millis(1)).await;

            match error_receiver.recv().await {
                Some(error) => {
                    // let quant = error_handler_quant_arc.lock().await;

                    error!("main: 订单出现错误{:?}", error);
                },
                None => {
                    error!("Error channel has been closed!");
                }
            }
        }
    });

    let server_thread = tokio::spawn(async move {
        // let server = server::run_server(5566, quant_arc);
        // info!("中控服务已运行。");
        // server.await
    });

    try_join!(order_handler_thread, error_handler_thread, server_thread).unwrap();
}