91 lines
2.4 KiB
Rust
91 lines
2.4 KiB
Rust
use std::{marker::Sized, path::PathBuf};
|
|
|
|
use bytes::BytesMut;
|
|
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
|
|
|
|
use crate::error::{Error, Result};
|
|
use crate::models::message::{Message, OpCode};
|
|
use crate::utils;
|
|
|
|
#[async_trait::async_trait]
|
|
pub trait Connection: Sized + Send {
|
|
type Socket: AsyncWrite + AsyncRead + Unpin + Send;
|
|
|
|
fn socket(&mut self) -> &mut Self::Socket;
|
|
|
|
fn ipc_path() -> PathBuf;
|
|
|
|
async fn connect() -> Result<Self>;
|
|
|
|
async fn disconnect(self) -> Result<()>;
|
|
|
|
fn socket_path(n: u8) -> PathBuf {
|
|
Self::ipc_path().join(format!("discord-ipc-{}", n))
|
|
}
|
|
|
|
async fn handshake(&mut self, client_id: u64) -> Result<()> {
|
|
let hs = json![{
|
|
"client_id": client_id.to_string(),
|
|
"v": 1,
|
|
"nonce": utils::nonce()
|
|
}];
|
|
|
|
self.send(Message::new(OpCode::Handshake, hs.clone()))
|
|
.await?;
|
|
self.recv().await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn ping(&mut self) -> Result<OpCode> {
|
|
let message = Message::new(OpCode::Ping, json![{}]);
|
|
self.send(message).await?;
|
|
let response = self.recv().await?;
|
|
Ok(response.opcode)
|
|
}
|
|
|
|
async fn send(&mut self, message: Message) -> Result<()> {
|
|
let bytes = message.encode()?;
|
|
match self.socket().write_all(bytes.as_ref()).await {
|
|
Ok(()) => {}
|
|
Err(e) => {
|
|
return match e.kind() {
|
|
std::io::ErrorKind::BrokenPipe => {
|
|
Err(Error::ConnectionClosedWhileSending(message))
|
|
}
|
|
_ => Err(e.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
debug!("-> {:?}", message);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn recv(&mut self) -> Result<Message> {
|
|
let mut buf = BytesMut::new();
|
|
buf.resize(1024, 0);
|
|
let n = match self.socket().read(&mut buf).await {
|
|
Ok(n) => n,
|
|
Err(e) => {
|
|
return match e.kind() {
|
|
std::io::ErrorKind::BrokenPipe => Err(Error::ConnectionClosed),
|
|
_ => Err(e.into()),
|
|
}
|
|
}
|
|
};
|
|
debug!("Received {} bytes", n);
|
|
|
|
if n == 0 {
|
|
return Err(Error::ConnectionClosed);
|
|
}
|
|
|
|
buf = buf.split_to(n);
|
|
let message = Message::decode(&buf)?;
|
|
debug!("<- {:?}", message);
|
|
|
|
Ok(message)
|
|
}
|
|
}
|