mirror of
https://github.com/scsibug/nostr-rs-relay.git
synced 2024-11-09 21:29:06 -05:00
feat: parse and validate events from websockets
Establishes a websocket listener, parses events, and performs validation to ensure valid signatures.
This commit is contained in:
parent
d0c2b242cd
commit
92e9a5e639
22
src/conn.rs
Normal file
22
src/conn.rs
Normal file
|
@ -0,0 +1,22 @@
|
||||||
|
//use std::collections::HashMap;
|
||||||
|
use uuid::Uuid;
|
||||||
|
|
||||||
|
// state for a client connection
|
||||||
|
pub struct ClientConn {
|
||||||
|
_client_id: Uuid,
|
||||||
|
// current set of subscriptions
|
||||||
|
//subscriptions: HashMap<String, Subscription>,
|
||||||
|
// websocket
|
||||||
|
//stream: WebSocketStream<TcpStream>,
|
||||||
|
_max_subs: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ClientConn {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
let client_id = Uuid::new_v4();
|
||||||
|
ClientConn {
|
||||||
|
_client_id: client_id,
|
||||||
|
_max_subs: 128,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
39
src/error.rs
Normal file
39
src/error.rs
Normal file
|
@ -0,0 +1,39 @@
|
||||||
|
//! Error handling.
|
||||||
|
|
||||||
|
use std::result;
|
||||||
|
use thiserror::Error;
|
||||||
|
use tungstenite::error::Error as WsError;
|
||||||
|
|
||||||
|
pub type Result<T, E = Error> = result::Result<T, E>;
|
||||||
|
|
||||||
|
#[derive(Error, Debug)]
|
||||||
|
pub enum Error {
|
||||||
|
#[error("Protocol parse error")]
|
||||||
|
ProtoParseError,
|
||||||
|
#[error("Connection error")]
|
||||||
|
ConnError,
|
||||||
|
#[error("Client write error")]
|
||||||
|
ConnWriteError,
|
||||||
|
#[error("Event parse failed")]
|
||||||
|
EventParseFailed,
|
||||||
|
#[error("Event validation failed")]
|
||||||
|
EventInvalid,
|
||||||
|
#[error("JSON parsing failed")]
|
||||||
|
JsonParseFailed(serde_json::Error),
|
||||||
|
#[error("WebSocket proto error")]
|
||||||
|
WebsocketError(WsError),
|
||||||
|
#[error("Command unknown")]
|
||||||
|
CommandUnknownError,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<serde_json::Error> for Error {
|
||||||
|
fn from(r: serde_json::Error) -> Self {
|
||||||
|
Error::JsonParseFailed(r)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<WsError> for Error {
|
||||||
|
fn from(r: WsError) -> Self {
|
||||||
|
Error::WebsocketError(r)
|
||||||
|
}
|
||||||
|
}
|
240
src/event.rs
Normal file
240
src/event.rs
Normal file
|
@ -0,0 +1,240 @@
|
||||||
|
use crate::error::Error::*;
|
||||||
|
use crate::error::Result;
|
||||||
|
use bitcoin_hashes::{sha256, Hash};
|
||||||
|
use log::info;
|
||||||
|
use secp256k1::{schnorrsig, Secp256k1};
|
||||||
|
use serde::{Deserialize, Deserializer, Serialize};
|
||||||
|
use serde_json::value::Value;
|
||||||
|
use serde_json::Number;
|
||||||
|
use std::str::FromStr;
|
||||||
|
|
||||||
|
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
|
||||||
|
pub struct EventCmd {
|
||||||
|
cmd: String, // expecting static "EVENT"
|
||||||
|
event: Event,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
|
||||||
|
pub struct Event {
|
||||||
|
pub(crate) id: String,
|
||||||
|
pub(crate) pubkey: String,
|
||||||
|
pub(crate) created_at: u64,
|
||||||
|
pub(crate) kind: u64,
|
||||||
|
#[serde(deserialize_with = "tag_from_string")]
|
||||||
|
// TODO: array-of-arrays may need to be more general than a string container
|
||||||
|
pub(crate) tags: Vec<Vec<String>>,
|
||||||
|
pub(crate) content: String,
|
||||||
|
pub(crate) sig: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
type Tag = Vec<Vec<String>>;
|
||||||
|
|
||||||
|
// handle a default value (empty vec) for null tags
|
||||||
|
fn tag_from_string<'de, D>(deserializer: D) -> Result<Tag, D::Error>
|
||||||
|
where
|
||||||
|
D: Deserializer<'de>,
|
||||||
|
{
|
||||||
|
let opt = Option::deserialize(deserializer)?;
|
||||||
|
Ok(opt.unwrap_or_else(|| vec![]))
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<EventCmd> for Result<Event> {
|
||||||
|
fn from(ec: EventCmd) -> Result<Event> {
|
||||||
|
// ensure command is correct
|
||||||
|
if ec.cmd != "EVENT" {
|
||||||
|
return Err(CommandUnknownError);
|
||||||
|
} else if ec.event.is_valid() {
|
||||||
|
return Ok(ec.event);
|
||||||
|
} else {
|
||||||
|
return Err(EventInvalid);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Event {
|
||||||
|
// check if this event is valid (should be propagated, stored) based on signature.
|
||||||
|
fn is_valid(&self) -> bool {
|
||||||
|
// validation is performed by:
|
||||||
|
// * parsing JSON string into event fields
|
||||||
|
// * create an array:
|
||||||
|
// ** [0, pubkey-hex-string, created-at-num, kind-num, tags-array-of-arrays, content-string]
|
||||||
|
// * serialize with no spaces/newlines
|
||||||
|
let c_opt = self.to_canonical();
|
||||||
|
if c_opt.is_none() {
|
||||||
|
info!("event could not be canonicalized");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
let c = c_opt.unwrap();
|
||||||
|
// * compute the sha256sum.
|
||||||
|
let digest: sha256::Hash = sha256::Hash::hash(&c.as_bytes());
|
||||||
|
let hex_digest = format!("{:x}", digest);
|
||||||
|
// * ensure the id matches the computed sha256sum.
|
||||||
|
if self.id != hex_digest {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
// * validate the message digest (sig) using the pubkey & computed sha256 message hash.
|
||||||
|
let secp = Secp256k1::new();
|
||||||
|
let sig = schnorrsig::Signature::from_str(&self.sig).unwrap();
|
||||||
|
let message = secp256k1::Message::from(digest);
|
||||||
|
let pubkey = schnorrsig::PublicKey::from_str(&self.pubkey).unwrap();
|
||||||
|
let verify = secp.schnorrsig_verify(&sig, &message, &pubkey);
|
||||||
|
match verify {
|
||||||
|
Ok(()) => {
|
||||||
|
info!("verified event");
|
||||||
|
true
|
||||||
|
}
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// convert event to canonical representation for signing
|
||||||
|
fn to_canonical(&self) -> Option<String> {
|
||||||
|
// create a JsonValue for each event element
|
||||||
|
let mut c: Vec<Value> = vec![];
|
||||||
|
// id must be set to 0
|
||||||
|
let id = Number::from(0 as u64);
|
||||||
|
c.push(serde_json::Value::Number(id));
|
||||||
|
// public key
|
||||||
|
c.push(Value::String(self.pubkey.to_owned()));
|
||||||
|
// creation time
|
||||||
|
let created_at = Number::from(self.created_at);
|
||||||
|
c.push(serde_json::Value::Number(created_at));
|
||||||
|
// kind
|
||||||
|
let kind = Number::from(self.kind);
|
||||||
|
c.push(serde_json::Value::Number(kind));
|
||||||
|
// tags
|
||||||
|
c.push(self.tags_to_canonical());
|
||||||
|
// content
|
||||||
|
c.push(Value::String(self.content.to_owned()));
|
||||||
|
serde_json::to_string(&Value::Array(c)).ok()
|
||||||
|
}
|
||||||
|
fn tags_to_canonical(&self) -> Value {
|
||||||
|
let mut tags = Vec::<Value>::new();
|
||||||
|
// iterate over self tags,
|
||||||
|
for t in self.tags.iter() {
|
||||||
|
// each tag is a vec of strings
|
||||||
|
let mut a = Vec::<Value>::new();
|
||||||
|
for v in t.iter() {
|
||||||
|
a.push(serde_json::Value::String(v.to_owned()));
|
||||||
|
}
|
||||||
|
tags.push(serde_json::Value::Array(a));
|
||||||
|
}
|
||||||
|
serde_json::Value::Array(tags)
|
||||||
|
}
|
||||||
|
|
||||||
|
// check if given event is referenced in a tag
|
||||||
|
pub fn event_tag_match(&self, eventid: &str) -> bool {
|
||||||
|
for t in self.tags.iter() {
|
||||||
|
if t.len() == 2 {
|
||||||
|
if t.get(0).unwrap() == "#e" {
|
||||||
|
if t.get(1).unwrap() == eventid {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
fn simple_event() -> Event {
|
||||||
|
Event {
|
||||||
|
id: "0".to_owned(),
|
||||||
|
pubkey: "0".to_owned(),
|
||||||
|
created_at: 0,
|
||||||
|
kind: 0,
|
||||||
|
tags: vec![],
|
||||||
|
content: "".to_owned(),
|
||||||
|
sig: "0".to_owned(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_creation() {
|
||||||
|
// create an event
|
||||||
|
let event = simple_event();
|
||||||
|
assert_eq!(event.id, "0");
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_serialize() -> Result<()> {
|
||||||
|
// serialize an event to JSON string
|
||||||
|
let event = simple_event();
|
||||||
|
let j = serde_json::to_string(&event)?;
|
||||||
|
assert_eq!(j, "{\"id\":\"0\",\"pubkey\":\"0\",\"created_at\":0,\"kind\":0,\"tags\":[],\"content\":\"\",\"sig\":\"0\"}");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_tags_serialize() -> Result<()> {
|
||||||
|
// serialize an event with tags to JSON string
|
||||||
|
let mut event = simple_event();
|
||||||
|
event.tags = vec![
|
||||||
|
vec![
|
||||||
|
"e".to_owned(),
|
||||||
|
"xxxx".to_owned(),
|
||||||
|
"wss://example.com".to_owned(),
|
||||||
|
],
|
||||||
|
vec![
|
||||||
|
"p".to_owned(),
|
||||||
|
"yyyyy".to_owned(),
|
||||||
|
"wss://example.com:3033".to_owned(),
|
||||||
|
],
|
||||||
|
];
|
||||||
|
let j = serde_json::to_string(&event)?;
|
||||||
|
assert_eq!(j, "{\"id\":\"0\",\"pubkey\":\"0\",\"created_at\":0,\"kind\":0,\"tags\":[[\"e\",\"xxxx\",\"wss://example.com\"],[\"p\",\"yyyyy\",\"wss://example.com:3033\"]],\"content\":\"\",\"sig\":\"0\"}");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_deserialize() -> Result<()> {
|
||||||
|
let raw_json = r#"{"id":"1384757da583e6129ce831c3d7afc775a33a090578f888dd0d010328ad047d0c","pubkey":"bbbd9711d357df4f4e498841fd796535c95c8e751fa35355008a911c41265fca","created_at":1612650459,"kind":1,"tags":null,"content":"hello world","sig":"59d0cc47ab566e81f72fe5f430bcfb9b3c688cb0093d1e6daa49201c00d28ecc3651468b7938642869ed98c0f1b262998e49a05a6ed056c0d92b193f4e93bc21"}"#;
|
||||||
|
let e: Event = serde_json::from_str(raw_json)?;
|
||||||
|
assert_eq!(e.kind, 1);
|
||||||
|
assert_eq!(e.tags.len(), 0);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_canonical() {
|
||||||
|
let e = Event {
|
||||||
|
id: "999".to_owned(),
|
||||||
|
pubkey: "012345".to_owned(),
|
||||||
|
created_at: 501234,
|
||||||
|
kind: 1,
|
||||||
|
tags: vec![],
|
||||||
|
content: "this is a test".to_owned(),
|
||||||
|
sig: "abcde".to_owned(),
|
||||||
|
};
|
||||||
|
let c = e.to_canonical();
|
||||||
|
let expected = Some(r#"[0,"012345",501234,1,[],"this is a test"]"#.to_owned());
|
||||||
|
assert_eq!(c, expected);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn event_canonical_with_tags() {
|
||||||
|
let e = Event {
|
||||||
|
id: "999".to_owned(),
|
||||||
|
pubkey: "012345".to_owned(),
|
||||||
|
created_at: 501234,
|
||||||
|
kind: 1,
|
||||||
|
tags: vec![
|
||||||
|
vec!["#e".to_owned(), "aoeu".to_owned()],
|
||||||
|
vec![
|
||||||
|
"#p".to_owned(),
|
||||||
|
"aaaa".to_owned(),
|
||||||
|
"ws://example.com".to_owned(),
|
||||||
|
],
|
||||||
|
],
|
||||||
|
content: "this is a test".to_owned(),
|
||||||
|
sig: "abcde".to_owned(),
|
||||||
|
};
|
||||||
|
let c = e.to_canonical();
|
||||||
|
let expected_json = r###"[0,"012345",501234,1,[["#e","aoeu"],["#p","aaaa","ws://example.com"]],"this is a test"]"###;
|
||||||
|
let expected = Some(expected_json.to_owned());
|
||||||
|
assert_eq!(c, expected);
|
||||||
|
}
|
||||||
|
}
|
4
src/lib.rs
Normal file
4
src/lib.rs
Normal file
|
@ -0,0 +1,4 @@
|
||||||
|
pub mod conn;
|
||||||
|
pub mod error;
|
||||||
|
pub mod event;
|
||||||
|
pub mod protostream;
|
104
src/main.rs
104
src/main.rs
|
@ -1,3 +1,103 @@
|
||||||
fn main() {
|
use futures::StreamExt;
|
||||||
println!("Hello, world!");
|
use log::*;
|
||||||
|
use nostr_rs_relay::conn;
|
||||||
|
use nostr_rs_relay::error::{Error, Result};
|
||||||
|
use nostr_rs_relay::event::Event;
|
||||||
|
use nostr_rs_relay::protostream;
|
||||||
|
use nostr_rs_relay::protostream::NostrMessage::*;
|
||||||
|
use rusqlite::Result as SQLResult;
|
||||||
|
use std::env;
|
||||||
|
use tokio::net::{TcpListener, TcpStream};
|
||||||
|
use tokio::runtime::Builder;
|
||||||
|
use tokio::sync::broadcast;
|
||||||
|
use tokio::sync::broadcast::Sender;
|
||||||
|
use tokio::sync::mpsc;
|
||||||
|
|
||||||
|
/// Start running a Nostr relay server.
|
||||||
|
fn main() -> Result<(), Error> {
|
||||||
|
// setup logger
|
||||||
|
let _ = env_logger::try_init();
|
||||||
|
let addr = env::args()
|
||||||
|
.nth(1)
|
||||||
|
.unwrap_or_else(|| "0.0.0.0:8888".to_string());
|
||||||
|
// configure tokio runtime
|
||||||
|
let rt = Builder::new_multi_thread()
|
||||||
|
.enable_all()
|
||||||
|
.thread_name("tokio-ws")
|
||||||
|
.build()
|
||||||
|
.unwrap();
|
||||||
|
// start tokio
|
||||||
|
rt.block_on(async {
|
||||||
|
let listener = TcpListener::bind(&addr).await.expect("Failed to bind");
|
||||||
|
info!("Listening on: {}", addr);
|
||||||
|
// Establish global broadcast channel. This is where all
|
||||||
|
// accepted events will be distributed for other connected clients.
|
||||||
|
let (bcast_tx, _) = broadcast::channel::<Event>(64);
|
||||||
|
// Establish database writer channel. This needs to be
|
||||||
|
// accessible from sync code, which is why the broadcast
|
||||||
|
// cannot be reused.
|
||||||
|
let (event_tx, _) = mpsc::channel::<Event>(64);
|
||||||
|
// start the database writer.
|
||||||
|
// TODO: manage program termination, to close the DB.
|
||||||
|
//let _db_handle = db_writer(event_rx).await;
|
||||||
|
while let Ok((stream, _)) = listener.accept().await {
|
||||||
|
tokio::spawn(nostr_server(stream, bcast_tx.clone(), event_tx.clone()));
|
||||||
|
}
|
||||||
|
});
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn _db_writer(_event_rx: tokio::sync::mpsc::Receiver<Event>) -> SQLResult<()> {
|
||||||
|
unimplemented!();
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn nostr_server(
|
||||||
|
stream: TcpStream,
|
||||||
|
broadcast: Sender<Event>,
|
||||||
|
_event_tx: tokio::sync::mpsc::Sender<Event>,
|
||||||
|
) {
|
||||||
|
// get a broadcast channel for clients to communicate on
|
||||||
|
// wrap the TCP stream in a websocket.
|
||||||
|
let mut _bcast_rx = broadcast.subscribe();
|
||||||
|
let conn = tokio_tungstenite::accept_async(stream).await;
|
||||||
|
let ws_stream = conn.expect("websocket handshake error");
|
||||||
|
// a stream & sink of Nostr protocol messages
|
||||||
|
let mut nostr_stream = protostream::wrap_ws_in_nostr(ws_stream);
|
||||||
|
//let task_queue = mpsc::channel::<NostrMessage>(16);
|
||||||
|
// track connection state so we can break when it fails
|
||||||
|
// Track internal client state
|
||||||
|
let _conn = conn::ClientConn::new();
|
||||||
|
let mut conn_good = true;
|
||||||
|
loop {
|
||||||
|
tokio::select! {
|
||||||
|
proto_next = nostr_stream.next() => {
|
||||||
|
match proto_next {
|
||||||
|
Some(Ok(EventMsg(e))) => {
|
||||||
|
// handle each type of message
|
||||||
|
let _x : Result<Event> = Result::<Event>::from(e);
|
||||||
|
},
|
||||||
|
Some(Ok(SubMsg)) => {},
|
||||||
|
Some(Ok(CloseMsg)) => {},
|
||||||
|
None => {
|
||||||
|
info!("stream ended");
|
||||||
|
//conn_good = true;
|
||||||
|
},
|
||||||
|
Some(Err(Error::ConnError)) => {
|
||||||
|
info!("got connection error, disconnecting");
|
||||||
|
conn_good = false;
|
||||||
|
if conn_good {
|
||||||
|
info!("Lint bug?, https://github.com/rust-lang/rust/pull/57302");
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
Some(Err(e)) => {
|
||||||
|
info!("got error, continuing: {:?}", e);
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if conn_good == false {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
99
src/protostream.rs
Normal file
99
src/protostream.rs
Normal file
|
@ -0,0 +1,99 @@
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::event::EventCmd;
|
||||||
|
use core::pin::Pin;
|
||||||
|
use futures::sink::Sink;
|
||||||
|
use futures::stream::Stream;
|
||||||
|
use futures::task::Context;
|
||||||
|
use futures::task::Poll;
|
||||||
|
use log::*;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use tokio::net::TcpStream;
|
||||||
|
use tokio_tungstenite::WebSocketStream;
|
||||||
|
use tungstenite::error::Error as WsError;
|
||||||
|
use tungstenite::protocol::Message;
|
||||||
|
|
||||||
|
// A Nostr message is either event, subscription, or close.
|
||||||
|
#[derive(Deserialize, Serialize, Clone, PartialEq, Debug)]
|
||||||
|
#[serde(untagged)]
|
||||||
|
pub enum NostrMessage {
|
||||||
|
EventMsg(EventCmd),
|
||||||
|
SubMsg,
|
||||||
|
CloseMsg,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Either an event w/ subscription, or a notice
|
||||||
|
#[derive(Deserialize, Serialize, Clone, PartialEq, Debug)]
|
||||||
|
enum NostrResponse {
|
||||||
|
Notice(String),
|
||||||
|
}
|
||||||
|
|
||||||
|
// A Nostr protocol stream is layered on top of a Websocket stream.
|
||||||
|
pub struct NostrStream {
|
||||||
|
ws_stream: WebSocketStream<TcpStream>,
|
||||||
|
}
|
||||||
|
|
||||||
|
// given a websocket, return a protocol stream
|
||||||
|
//impl Stream<Item = Result<BasicMessage, BasicError>> + Sink<BasicResponse>
|
||||||
|
pub fn wrap_ws_in_nostr(ws: WebSocketStream<TcpStream>) -> NostrStream {
|
||||||
|
return NostrStream { ws_stream: ws };
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Stream for NostrStream {
|
||||||
|
type Item = Result<NostrMessage>;
|
||||||
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||||
|
// convert Message to NostrMessage
|
||||||
|
fn convert(msg: String) -> Result<NostrMessage> {
|
||||||
|
debug!("Input message: {}", &msg);
|
||||||
|
let parsed_res: Result<NostrMessage> = serde_json::from_str(&msg).map_err(|e| e.into());
|
||||||
|
match parsed_res {
|
||||||
|
Ok(m) => Ok(m),
|
||||||
|
Err(e) => {
|
||||||
|
debug!("Proto parse error: {:?}", e);
|
||||||
|
Err(Error::ProtoParseError)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
match Pin::new(&mut self.ws_stream).poll_next(cx) {
|
||||||
|
Poll::Pending => Poll::Pending, // not ready
|
||||||
|
Poll::Ready(None) => Poll::Ready(None), // done
|
||||||
|
Poll::Ready(Some(v)) => match v {
|
||||||
|
Ok(Message::Text(vs)) => Poll::Ready(Some(convert(vs))), // convert message->basicmessage
|
||||||
|
Ok(Message::Binary(_)) => Poll::Ready(Some(Err(Error::ProtoParseError))),
|
||||||
|
Ok(Message::Pong(_)) | Ok(Message::Ping(_)) => Poll::Pending,
|
||||||
|
Ok(Message::Close(_)) => Poll::Ready(None),
|
||||||
|
Err(WsError::AlreadyClosed) | Err(WsError::ConnectionClosed) => Poll::Ready(None), // done
|
||||||
|
Err(_) => Poll::Ready(Some(Err(Error::ConnError))),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Sink<NostrResponse> for NostrStream {
|
||||||
|
type Error = Error;
|
||||||
|
|
||||||
|
fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
||||||
|
// map the error type
|
||||||
|
match Pin::new(&mut self.ws_stream).poll_ready(cx) {
|
||||||
|
Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
|
||||||
|
Poll::Ready(Err(_)) => Poll::Ready(Err(Error::ConnWriteError)),
|
||||||
|
Poll::Pending => Poll::Pending,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn start_send(mut self: Pin<&mut Self>, item: NostrResponse) -> Result<(), Self::Error> {
|
||||||
|
let res_message = serde_json::to_string(&item).expect("Could convert message to string");
|
||||||
|
match Pin::new(&mut self.ws_stream).start_send(Message::Text(res_message)) {
|
||||||
|
Ok(()) => Ok(()),
|
||||||
|
Err(_) => Err(Error::ConnWriteError),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
||||||
|
Poll::Ready(Ok(()))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn poll_close(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
||||||
|
Poll::Ready(Ok(()))
|
||||||
|
}
|
||||||
|
}
|
Loading…
Reference in New Issue
Block a user