优化代码

exchanges/src/binance_spot_rest.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-
+#[derive(Clone)]
 pub struct BinanceSpotRest {}
 
 impl BinanceSpotRest {

exchanges/src/binance_spot_ws.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-
+#[derive(Clone)]
 pub struct BinanceSpotWs {}
 
 impl BinanceSpotWs {

exchanges/src/binance_usdt_swap_rest.rs

@@ -4,7 +4,7 @@ use ring::hmac;
 use hex;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
-
+#[derive(Clone)]
 pub struct BinanceUsdtSwapRest {
     /*******参数*/
     //登陆所需参数
@@ -50,9 +50,9 @@ impl BinanceUsdtSwapRest {
             params,
             self.get_headers(true),
         ).await;
-        let mut req_data = RestTool::req_data_analysis(get_response);
-        req_data.channel = "account".to_string();
-        req_data
+        let mut res_data = RestTool::res_data_analysis(get_response);
+        res_data.channel = "account".to_string();
+        res_data
     }
     //持仓信息
     pub fn get_position(&self) {}

exchanges/src/binance_usdt_swap_ws.rs

@@ -11,7 +11,7 @@ use tungstenite::{connect, Message, WebSocket};
 use tungstenite::protocol::WebSocketConfig;
 use url::Url;
 
-
+#[derive(Clone)]
 pub struct BinanceUsdtSwapWs {
     /*******参数*/
     //连接地址
@@ -186,14 +186,14 @@ impl BinanceUsdtSwapWs {
             let msg = web_socket.read_message();
             match msg {
                 Ok(Message::Text(text)) => {
-                    let req_data = Self::ok_text(text);
-                    self.sender.send(req_data).unwrap();
-                    // writeln!(stdout, "Text-响应--{:?}", req_data).unwrap();
+                    let res_data = Self::ok_text(text);
+                    self.sender.send(res_data).unwrap();
+                    // writeln!(stdout, "Text-响应--{:?}", res_data).unwrap();
                     //
                     // let parse_fn_clone = Arc::clone(parse_fn); // Clone the Arc for each iteration
                     // tokio::spawn(async move {
                     //     let parse_fn_lock = parse_fn_clone.lock().await;
-                    //     parse_fn_lock(req_data).await;
+                    //     parse_fn_lock(res_data).await;
                     // });
                     // tokio::spawn(async move {});
                 }
@@ -248,13 +248,13 @@ impl BinanceUsdtSwapWs {
             let msg = web_socket.read_message();
             match msg {
                 Ok(Message::Text(text)) => {
-                    let req_data = Self::ok_text(text);
-                    self.sender.send(req_data).unwrap();
-                    // writeln!(stdout, "Pong-响应--{:?}", req_data).unwrap();
+                    let res_data = Self::ok_text(text);
+                    self.sender.send(res_data).unwrap();
+                    // writeln!(stdout, "Pong-响应--{:?}", res_data).unwrap();
                     // let parse_fn_clone = Arc::clone(parse_fn); // Clone the Arc for each iteration
                     // tokio::spawn(async move {
                     //     let parse_fn_lock = parse_fn_clone.lock().await;
-                    //     parse_fn_lock(req_data).await;
+                    //     parse_fn_lock(res_data).await;
                     // });
                 }
                 Ok(Message::Ping(s)) => {

exchanges/src/gate_spot_rest.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-
+#[derive(Clone)]
 pub struct GateSpotRest {}
 
 impl GateSpotRest {

exchanges/src/gate_spot_ws.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-
+#[derive(Clone)]
 pub struct GateSpotWs {}
 
 impl GateSpotWs {

exchanges/src/gate_swap_rest.rs

@@ -7,7 +7,7 @@ use reqwest::Client;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
 use sha2::Sha512;
-
+#[derive(Clone)]
 pub struct GateSwapRest {
     base_url: String,
     client: reqwest::Client,
@@ -327,8 +327,8 @@ impl GateSwapRest {
             params,
             headers,
         ).await;
-        let  req_data = Self::req_data_analysis(get_response);
-        req_data
+        let  res_data = Self::res_data_analysis(get_response);
+        res_data
     }
 
     pub fn headers(access_key: String, timestamp: String, sign: String) -> HeaderMap {
@@ -373,7 +373,7 @@ impl GateSwapRest {
 
 
     async fn http_toll(&self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
-        let req_data: ResponseData;
+        let res_data: ResponseData;
         /****请求接口与 地址*/
         let url = format!("{}{}", self.base_url.to_string(), request_path);
         let request_type = request_type.clone().to_uppercase();
@@ -397,23 +397,23 @@ impl GateSwapRest {
             // 读取响应的内容
             let body = response.text().await?;
             // println!("ok-----{}", body);
-            req_data = ResponseData::new("200".to_string(), "success".to_string(), body);
+            res_data = ResponseData::new("200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
             // println!("error-----{}", body);
-            req_data = ResponseData::error(body.to_string())
+            res_data = ResponseData::error(body.to_string())
         }
-        Ok(req_data)
+        Ok(res_data)
     }
 
-    //req_data 解析
-    pub fn req_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
+    //res_data 解析
+    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
         match result {
-            Ok(req_data) => {
-                if req_data.code != "200" {
-                    req_data
+            Ok(res_data) => {
+                if res_data.code != "200" {
+                    res_data
                 } else {
-                    req_data
+                    res_data
                 }
             }
             Err(err) => {

exchanges/src/gate_swap_ws.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-
+#[derive(Clone)]
 pub struct GateSwapWs {}
 
 impl GateSwapWs {

exchanges/src/http_tool.rs

@@ -1,7 +1,7 @@
 use reqwest::{Client};
 use reqwest::header::HeaderMap;
 use crate::response_base::ResponseData;
-
+#[derive(Clone)]
 pub struct RestTool {
     pub base_url: String,
     client: Client,
@@ -23,14 +23,14 @@ impl RestTool {
             params.to_string(),
             HeaderMap::new(),
         ).await;
-        let req_data = RestTool::req_data_analysis(get_response);
-        println!("GET Response: {:?}", req_data);
+        let res_data = RestTool::res_data_analysis(get_response);
+        println!("GET Response: {:?}", res_data);
 
 
         Ok(())
     }
     pub async fn http_toll(&self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
-        let req_data: ResponseData;
+        let res_data: ResponseData;
         /****请求接口与 地址*/
         let url = format!("{}{}", self.base_url.to_string(), request_path);
         let request_type = request_type.clone().to_uppercase();
@@ -54,13 +54,13 @@ impl RestTool {
             // 读取响应的内容
             let body = response.text().await?;
             // println!("ok-----{}", body);
-            req_data = ResponseData::new("200".to_string(), "success".to_string(), body);
+            res_data = ResponseData::new("200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
             // println!("error-----{}", body);
-            req_data = ResponseData::error(body.to_string())
+            res_data = ResponseData::error(body.to_string())
         }
-        Ok(req_data)
+        Ok(res_data)
     }
 
     //map数据转 get请求参数
@@ -88,14 +88,14 @@ impl RestTool {
         // println!("---json-转字符串拼接:{}",params_str);
         params_str.to_string()
     }
-    //req_data 解析
-    pub fn req_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
+    //res_data 解析
+    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
         match result {
-            Ok(req_data) => {
-                if req_data.code != "0" {
-                    req_data
+            Ok(res_data) => {
+                if res_data.code != "0" {
+                    res_data
                 } else {
-                    let body: String = req_data.data;
+                    let body: String = res_data.data;
                     let json_value: serde_json::Value = serde_json::from_str(&body).unwrap();
 
                     let code = json_value["code"].as_str().unwrap();

exchanges/src/kucoin_swap_rest.rs

@@ -5,7 +5,7 @@ use reqwest::{Client};
 use sha2::Sha256;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
-
+#[derive(Clone)]
 pub struct KucoinSwapRest {
     base_url: String,
     client: reqwest::Client,
@@ -225,16 +225,38 @@ impl KucoinSwapRest {
         data
     }
 
+    //获取合约令牌-公共
+    pub async fn get_public_token(&self) -> ResponseData {
+        let mut params = serde_json::json!({});
+        let data = self.request("POST".to_string(),
+                                "/api/v1".to_string(),
+                                "/bullet-public".to_string(),
+                                false,
+                                params.to_string(),
+        ).await;
+        data
+    }
+    //获取合约令牌-私有
+    pub async fn get_private_token(&self) -> ResponseData {
+        let mut params = serde_json::json!({});
+        let data = self.request("POST".to_string(),
+                                "/api/v1".to_string(),
+                                "/bullet-private".to_string(),
+                                true,
+                                params.to_string(),
+        ).await;
+        data
+    }
     /*******************************************************************************************************/
     /*****************************************工具函数********************************************************/
     /*******************************************************************************************************/
     //调用请求
-    async fn request(&self,
-                     method: String,
-                     prefix_url: String,
-                     request_url: String,
-                     is_login: bool,
-                     params: String) -> ResponseData
+    pub async fn request(&self,
+                         method: String,
+                         prefix_url: String,
+                         request_url: String,
+                         is_login: bool,
+                         params: String) -> ResponseData
     {
         println!("login_param:{:?}", self.login_param);
         //解析账号信息
@@ -301,8 +323,8 @@ impl KucoinSwapRest {
             headers,
         ).await;
 
-        let req_data = Self::req_data_analysis(get_response);
-        req_data
+        let res_data = Self::res_data_analysis(get_response);
+        res_data
     }
 
     pub fn headers(sign: String, timestamp: String, passphrase: String, access_key: String) -> HeaderMap {
@@ -368,7 +390,7 @@ impl KucoinSwapRest {
 
 
     async fn http_toll(&self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
-        let req_data: ResponseData;
+        let res_data: ResponseData;
         /****请求接口与 地址*/
         let url = format!("{}{}", self.base_url.to_string(), request_path);
         let request_type = request_type.clone().to_uppercase();
@@ -393,24 +415,24 @@ impl KucoinSwapRest {
             // 读取响应的内容
             let body = response.text().await?;
             // println!("ok-----{}", body);
-            req_data = ResponseData::new("200".to_string(), "success".to_string(), body);
+            res_data = ResponseData::new("200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
             // println!("error-----{}", body);
-            req_data = ResponseData::error(body.to_string())
+            res_data = ResponseData::error(body.to_string())
         }
-        Ok(req_data)
+        Ok(res_data)
     }
 
 
-    //req_data 解析
-    pub fn req_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
+    //res_data 解析
+    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>) -> ResponseData {
         match result {
-            Ok(req_data) => {
-                if req_data.code != "200" {
-                    req_data
+            Ok(res_data) => {
+                if res_data.code != "200" {
+                    res_data
                 } else {
-                    let body: String = req_data.data;
+                    let body: String = res_data.data;
                     let json_value: serde_json::Value = serde_json::from_str(&body).unwrap();
 
                     let code = json_value["code"].as_str().unwrap();

exchanges/src/lib.rs

@@ -11,5 +11,12 @@ pub mod gate_swap_ws;
 pub mod gate_swap_rest;
 pub mod socket_tool;
 pub mod kucoin_swap_rest;
+pub mod kuconin_swap_ws;
+
+
+pub enum  WsType{
+    Public,
+    Private,
+}
 
 

exchanges/src/socket_tool.rs

@@ -1,94 +1,189 @@
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-use crate::proxy;
-use tungstenite::client::{  connect_with_proxy, ProxyAutoStream};
-use tungstenite::{ WebSocket};
-use tungstenite::protocol::WebSocketConfig;
-use url::Url;
-use crate::proxy::ParsingDetail;
-
-
-pub enum WsType {
-    WsP(WsProxy),
-    Ws(WsNoProxy),
-}
-
-
-#[derive(Debug)]
-pub struct WsProxy {
-    socket: Option<WebSocket<ProxyAutoStream>>,
-    proxy: ParsingDetail,
-}
-
-impl WsProxy {
-    pub fn new(proxy: ParsingDetail) -> WsProxy {
-        WsProxy { socket: None, proxy }
-    }
-    pub fn connect(&mut self, base_url: String) {
-        let request_url = Url::parse(base_url.as_str()).unwrap();
-
-
-        let ip_array: Vec<&str> = self.proxy.ip_address.split(".").collect();
-        let proxy_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(
-            ip_array[0].parse().unwrap(),
-            ip_array[1].parse().unwrap(),
-            ip_array[2].parse().unwrap(),
-            ip_array[3].parse().unwrap())
-        ), self.proxy.port.parse().unwrap());
-        let websocket_config = Some(WebSocketConfig {
-            max_send_queue: Some(16),
-            max_message_size: Some(16 * 1024 * 1024),
-            max_frame_size: Some(16 * 1024 * 1024),
-            accept_unmasked_frames: false,
-        });
-        let max_redirects = 5;
-        match connect_with_proxy(request_url.clone(), proxy_address, websocket_config, max_redirects) {
-            Ok((socket, _)) => {
-                // 连接成功，可以继续处理逻辑
-                self.socket = Option::from(socket);
-                println!("----ws-链接成功");
-            }
-            Err(err) => {
-                panic!("连接代理失败:{:?}", err);
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct WsNoProxy {}
-
-impl WsNoProxy {
-    pub fn new() -> WsNoProxy {
-        WsNoProxy {}
-    }
-    pub fn connect(&mut self, base_url: String, proxy_ip: String, proxy_port: u16) -> Result<bool, bool> {
-        Ok(true)
-    }
-}
-
-pub struct WsTool {
-    base_url: String,
-    socket: WsType,
-}
-
-impl WsTool {
-    pub fn new(base_url: String) -> WsTool {
-        /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
-        let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
-        if parsing_detail.ip_address.len() > 0 && parsing_detail.port.len() > 0 {
-            WsTool { base_url, socket: WsType::WsP(WsProxy::new(parsing_detail)) }
-        } else {
-            WsTool { base_url, socket: WsType::Ws(WsNoProxy::new()) }
-        }
-    }
-    pub fn connect(&self) {
-        let url = self.base_url.clone();
-        match &self.socket {
-            WsType::WsP(ws_no_proxy) => {
-                // let mut mutable_ws = ws_no_proxy.clone();
-                // mutable_ws.connect(url);
-            }
-            WsType::Ws(ws_no_proxy) => {}
-        }
-    }
-}
+// use std::io;
+// use std::io::{Write};
+// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+// use crate::proxy;
+// use tungstenite::client::{AutoStream, connect_with_proxy, ProxyAutoStream};
+// use tungstenite::{Message, WebSocket};
+// use tungstenite::protocol::WebSocketConfig;
+// use url::Url;
+// use crate::proxy::ParsingDetail;
+// use crate::socket_tool::WsType::{WsNone, WsP};
+//
+//
+// pub enum WsType {
+//     WsP(WebSocket<ProxyAutoStream>),
+//     Ws(WebSocket<AutoStream>),
+//     WsNone(String),
+// }
+//
+//
+// #[derive(Debug)]
+// pub struct WsProxy {
+//     socket: Option<WebSocket<ProxyAutoStream>>,
+//     proxy: ParsingDetail,
+// }
+//
+// impl WsProxy {
+//     pub fn new(proxy: ParsingDetail) -> WsProxy {
+//         WsProxy { socket: None, proxy }
+//     }
+//     pub fn connect(&mut self, base_url: String) {
+//         loop {
+//             println!("--开始链接：");
+//             let request_url = Url::parse(base_url.as_str()).unwrap();
+//
+//             let ip_array: Vec<&str> = self.proxy.ip_address.split(".").collect();
+//             let proxy_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(
+//                 ip_array[0].parse().unwrap(),
+//                 ip_array[1].parse().unwrap(),
+//                 ip_array[2].parse().unwrap(),
+//                 ip_array[3].parse().unwrap())
+//             ), self.proxy.port.parse().unwrap());
+//             let websocket_config = Some(WebSocketConfig {
+//                 max_send_queue: Some(16),
+//                 max_message_size: Some(16 * 1024 * 1024),
+//                 max_frame_size: Some(16 * 1024 * 1024),
+//                 accept_unmasked_frames: false,
+//             });
+//             let max_redirects = 5;
+//             let ws = match connect_with_proxy(request_url.clone(), proxy_address, websocket_config, max_redirects) {
+//                 Ok((socket, res)) => {
+//                     socket
+//                 }
+//                 Err(err) => {
+//                     println!("连接代理失败:{:?},重连启动", err);
+//                     continue;
+//                 }
+//             };
+//             self.socket = Option::from(ws);
+//         }
+//     }
+//     pub fn subscription(ws_proxy: &WsProxy) {
+//         loop {}
+//     }
+// }
+//
+// #[derive(Debug)]
+// pub struct WsNoProxy {}
+//
+// impl WsNoProxy {
+//     pub fn new() -> WsNoProxy {
+//         WsNoProxy {}
+//     }
+//     pub fn connect(&mut self, base_url: String, proxy_ip: String, proxy_port: u16) -> Result<bool, bool> {
+//         Ok(true)
+//     }
+// }
+//
+// pub struct WsTool {
+//     base_url: String,
+//     ws_type: WsType,
+//     proxy: ParsingDetail,
+// }
+//
+// impl WsTool {
+//     pub fn new(base_url: String) -> WsTool {
+//         /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
+//         let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
+//         if parsing_detail.ip_address.len() > 0 && parsing_detail.port.len() > 0 {
+//             WsTool { base_url, ws_type: WsP(""), proxy: parsing_detail }
+//         } else {
+//             WsTool { base_url, ws_type: WsType::Ws(WebSocket::<AutoStream>::new()), proxy: parsing_detail }
+//         }
+//     }
+//     pub fn connect(&mut self) {
+//         let mut res = false;
+//         match &self.ws_type {
+//             WsType::WsP(ws_p) => {
+//                 self.proxy_connect();
+//             }
+//             WsType::Ws(ws_p) => {
+//                 self.proxy_connect();
+//             }
+//             WsNone(ws_none) => {}
+//         }
+//     }
+//     pub fn read(&mut self) {
+//         let mut res = false;
+//         match &self.ws_type {
+//             WsType::WsP(ws_p) => {
+//                 println!("????????");
+//                 loop {
+//                     println!("1231321");
+//                 }
+//             }
+//             WsType::Ws(ws_p) => {}
+//             WsNone(ws_none) => {}
+//         }
+//     }
+//
+//
+//     /**读取*/
+//     // pub fn proxy_read(mut ws_p: &WebSocket<ProxyAutoStream>) {
+//     //     /*****消息溜***/
+//     //     let mut stdout = io::stdout();
+//     //     let mut stderr = io::stderr();
+//     //     /******订阅信息********/
+//     //     loop {
+//     //         let msg =ws_p.read_message();
+//     //         match msg {
+//     //             Ok(Message::Text(text)) => {
+//     //                 writeln!(stdout, "Text-响应--{:?}", text.clone()).unwrap();
+//     //             }
+//     //             Ok(Message::Ping(s)) => {
+//     //                 writeln!(stdout, "Ping-响应--{:?}", String::from_utf8(s.clone())).unwrap();
+//     //                 let _ = ws_p.write_message(Message::Pong(Vec::from("pong")));
+//     //                 writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
+//     //             }
+//     //             Ok(Message::Pong(s)) => {
+//     //                 // println!("Pong-响应--{:?}", String::from_utf8(s));
+//     //                 writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
+//     //             }
+//     //             Ok(Message::Close(_)) => {
+//     //                 // println!("socket 关闭: ");
+//     //                 writeln!(stdout, "Close-响应").unwrap();
+//     //             }
+//     //             Err(error) => {
+//     //                 // println!("Error receiving message: {}", error);
+//     //                 writeln!(stdout, "Err-响应{}", error).unwrap();
+//     //                 break;
+//     //             }
+//     //             _ => {}
+//     //         }
+//     //     }
+//     //     ws_p.close(None).unwrap();
+//     // }
+//
+//     /**链接*/
+//     //代理
+//     pub fn proxy_connect(&mut self) {
+//         println!("--开始链接：");
+//         let request_url = Url::parse(self.base_url.as_str()).unwrap();
+//
+//         let ip_array: Vec<&str> = self.proxy.ip_address.split(".").collect();
+//         let proxy_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(
+//             ip_array[0].parse().unwrap(),
+//             ip_array[1].parse().unwrap(),
+//             ip_array[2].parse().unwrap(),
+//             ip_array[3].parse().unwrap())
+//         ), self.proxy.port.parse().unwrap());
+//         let websocket_config = Some(WebSocketConfig {
+//             max_send_queue: Some(16),
+//             max_message_size: Some(16 * 1024 * 1024),
+//             max_frame_size: Some(16 * 1024 * 1024),
+//             accept_unmasked_frames: false,
+//         });
+//         let max_redirects = 5;
+//         let ws = match connect_with_proxy(request_url.clone(), proxy_address, websocket_config, max_redirects) {
+//             Ok((socket, res)) => {
+//                 socket
+//             }
+//             Err(err) => {
+//                 println!("连接代理失败:{:?},重连启动", err);
+//                 return;
+//             }
+//         };
+//         self.ws_type = WsP(ws);
+//     }
+//     //非代理
+// }