14228368139

Committed 02 Apr 2025 07:54PM UTC coverage: 80.879% (-0.7%) from 81.608%

Build # 14228368139

Build Type

Pull #631

github

Committed by

web-flow

Commit Message

Merge fe2ceba4a into fde867b93

Pull Request Pull Request #631: Create clear command in payjoin-cli

Coverage Stats

26 of 89 new or added lines in 5 files covered. (29.21%)

1 existing line in 1 file now uncovered.

5279 of 6527 relevant lines covered (80.88%)

708.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.96

/payjoin-cli/src/db/v2.rs

use std::sync::Arc;

use bitcoincore_rpc::jsonrpc::serde_json;
use payjoin::persist::{Persister, Value};
use payjoin::receive::v2::{Receiver, ReceiverToken};
use payjoin::send::v2::{Sender, SenderToken};
use sled::Tree;
use url::Url;

use super::*;

pub(crate) struct SenderPersister(Arc<Database>);
impl SenderPersister {
    pub fn new(db: Arc<Database>) -> Self { Self(db) }
}

impl Persister<Sender> for SenderPersister {
    type Token = SenderToken;
    type Error = crate::db::error::Error;
    fn save(&mut self, value: Sender) -> std::result::Result<SenderToken, Self::Error> {
        let send_tree = self.0 .0.open_tree("send_sessions")?;
        let key = value.key();
        let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;
        send_tree.insert(key.clone(), value.as_slice())?;
        send_tree.flush()?;
        Ok(key)
    }

    fn load(&self, key: SenderToken) -> std::result::Result<Sender, Self::Error> {
        let send_tree = self.0 .0.open_tree("send_sessions")?;
        let value = send_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;
        serde_json::from_slice(&value).map_err(Error::Deserialize)
    }
}

pub(crate) struct ReceiverPersister(Arc<Database>);
impl ReceiverPersister {
    pub fn new(db: Arc<Database>) -> Self { Self(db) }
}

impl Persister<Receiver> for ReceiverPersister {
    type Token = ReceiverToken;
    type Error = crate::db::error::Error;
    fn save(&mut self, value: Receiver) -> std::result::Result<ReceiverToken, Self::Error> {
        let recv_tree = self.0 .0.open_tree("recv_sessions")?;
        let key = value.key();
        let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;
        recv_tree.insert(key.clone(), value.as_slice())?;
        recv_tree.flush()?;
        Ok(key)
    }
    fn load(&self, key: ReceiverToken) -> std::result::Result<Receiver, Self::Error> {
        let recv_tree = self.0 .0.open_tree("recv_sessions")?;
        let value = recv_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;
        serde_json::from_slice(&value).map_err(Error::Deserialize)
    }
}

impl Database {
    pub(crate) fn get_recv_sessions(&self) -> Result<Vec<Receiver>> {
        let recv_tree = self.0.open_tree("recv_sessions")?;
        let mut sessions = Vec::new();
        for item in recv_tree.iter() {
            let (_, value) = item?;
            let session: Receiver = serde_json::from_slice(&value).map_err(Error::Deserialize)?;
            sessions.push(session);
        }
        Ok(sessions)
    }

    pub(crate) fn clear_recv_sessions(&self) -> Result<()> {
        let recv_tree: Tree = self.0.open_tree("recv_sessions")?;
        recv_tree.clear()?;
        recv_tree.flush()?;
        Ok(())
    }

    pub(crate) fn get_recv_session(&self, pj_url: &Url) -> Result<Option<Receiver>> {
        let recv_tree = self.0.open_tree("recv_sessions")?;

        let result = recv_tree
            .iter()
            .filter_map(|entry| {
                let (_, value) = entry.ok()?;
                let receiver: Receiver = serde_json::from_slice(&value).ok()?;

                if receiver.pj_uri().extras.endpoint() == pj_url {
                    Some(receiver)
                } else {
                    None
                }
            })
            .find(|_| true);

        Ok(result)
    }

    pub(crate) fn clear_recv_session(&self, pj_url: &Url) -> Result<()> {
        let recv_tree = self.0.open_tree("recv_sessions")?;

        if let Some((key, _)) = recv_tree.iter().find_map(|entry| {
            let (key, value) = entry.ok()?;
            let receiver: Receiver = serde_json::from_slice(&value).ok()?;

            if receiver.pj_uri().extras.endpoint() == pj_url {
                Some((key, value))
            } else {
                None
            }
        }) {
            recv_tree.remove(key)?;
            recv_tree.flush()?;
        }

        Ok(())
    }

    pub(crate) fn get_send_sessions(&self) -> Result<Vec<Sender>> {
        let send_tree: Tree = self.0.open_tree("send_sessions")?;
        let mut sessions = Vec::new();
        for item in send_tree.iter() {
            let (_, value) = item?;
            let session: Sender = serde_json::from_slice(&value).map_err(Error::Deserialize)?;
            sessions.push(session);
        }
        Ok(sessions)
    }

    pub(crate) fn get_send_session(&self, pj_url: &Url) -> Result<Option<Sender>> {
        let send_tree = self.0.open_tree("send_sessions")?;
        if let Some(val) = send_tree.get(pj_url.as_str())? {
            let session: Sender = serde_json::from_slice(&val).map_err(Error::Deserialize)?;
            Ok(Some(session))
        } else {
            Ok(None)
        }
    }

    pub(crate) fn clear_send_session(&self, pj_url: &Url) -> Result<()> {
        let send_tree: Tree = self.0.open_tree("send_sessions")?;
        send_tree.remove(pj_url.as_str())?;
        send_tree.flush()?;
        Ok(())
    }
}

1	use std::sync::Arc;
2
3	use bitcoincore_rpc::jsonrpc::serde_json;
4	use payjoin::persist::{Persister, Value};
5	use payjoin::receive::v2::{Receiver, ReceiverToken};
6	use payjoin::send::v2::{Sender, SenderToken};
7	use sled::Tree;
8	use url::Url;
9
10	use super::*;
11
12	pub(crate) struct SenderPersister(Arc<Database>);
13	impl SenderPersister {
14	pub fn new(db: Arc<Database>) -> Self { Self(db) }	1✔
15	}
16
17	impl Persister<Sender> for SenderPersister {
18	type Token = SenderToken;
19	type Error = crate::db::error::Error;
20	fn save(&mut self, value: Sender) -> std::result::Result<SenderToken, Self::Error> {	1✔
21	let send_tree = self.0 .0.open_tree("send_sessions")?;	1✔
22	let key = value.key();	1✔
23	let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;	1✔
24	send_tree.insert(key.clone(), value.as_slice())?;	1✔
25	send_tree.flush()?;	1✔
26	Ok(key)	1✔
27	}	1✔
28
29	fn load(&self, key: SenderToken) -> std::result::Result<Sender, Self::Error> {	1✔
30	let send_tree = self.0 .0.open_tree("send_sessions")?;	1✔
31	let value = send_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;	1✔
32	serde_json::from_slice(&value).map_err(Error::Deserialize)	1✔
33	}	1✔
34	}
35
36	pub(crate) struct ReceiverPersister(Arc<Database>);
37	impl ReceiverPersister {
38	pub fn new(db: Arc<Database>) -> Self { Self(db) }	1✔
39	}
40
41	impl Persister<Receiver> for ReceiverPersister {
42	type Token = ReceiverToken;
43	type Error = crate::db::error::Error;
44	fn save(&mut self, value: Receiver) -> std::result::Result<ReceiverToken, Self::Error> {	1✔
45	let recv_tree = self.0 .0.open_tree("recv_sessions")?;	1✔
46	let key = value.key();	1✔
47	let value = serde_json::to_vec(&value).map_err(Error::Serialize)?;	1✔
48	recv_tree.insert(key.clone(), value.as_slice())?;	1✔
49	recv_tree.flush()?;	1✔
50	Ok(key)	1✔
51	}	1✔
52	fn load(&self, key: ReceiverToken) -> std::result::Result<Receiver, Self::Error> {	1✔
53	let recv_tree = self.0 .0.open_tree("recv_sessions")?;	1✔
54	let value = recv_tree.get(key.as_ref())?.ok_or(Error::NotFound(key.to_string()))?;	1✔
55	serde_json::from_slice(&value).map_err(Error::Deserialize)	1✔
56	}	1✔
57	}
58
59	impl Database {
60	pub(crate) fn get_recv_sessions(&self) -> Result<Vec<Receiver>> {	1✔
61	let recv_tree = self.0.open_tree("recv_sessions")?;	1✔
62	let mut sessions = Vec::new();	1✔
63	for item in recv_tree.iter() {	1✔
64	let (_, value) = item?;	1✔
65	let session: Receiver = serde_json::from_slice(&value).map_err(Error::Deserialize)?;	1✔
66	sessions.push(session);	1✔
67	}
68	Ok(sessions)	1✔
69	}	1✔
70
71	pub(crate) fn clear_recv_sessions(&self) -> Result<()> {	1✔
72	let recv_tree: Tree = self.0.open_tree("recv_sessions")?;	1✔
73	recv_tree.clear()?;	1✔
74	recv_tree.flush()?;	1✔
75	Ok(())	1✔
76	}	1✔
77
NEW 78	pub(crate) fn get_recv_session(&self, pj_url: &Url) -> Result<Option<Receiver>> {	×
NEW 79	let recv_tree = self.0.open_tree("recv_sessions")?;	×
80
NEW 81	let result = recv_tree	×
NEW 82	.iter()	×
NEW 83	.filter_map(\|entry\| {	×
NEW 84	let (_, value) = entry.ok()?;	×
NEW 85	let receiver: Receiver = serde_json::from_slice(&value).ok()?;	×
86
NEW 87	if receiver.pj_uri().extras.endpoint() == pj_url {	×
NEW 88	Some(receiver)	×
89	} else {
NEW 90	None	×
91	}
NEW 92	})	×
NEW 93	.find(\|_\| true);	×
NEW 94		×
NEW 95	Ok(result)	×
NEW 96	}	×
97
NEW 98	pub(crate) fn clear_recv_session(&self, pj_url: &Url) -> Result<()> {	×
NEW 99	let recv_tree = self.0.open_tree("recv_sessions")?;	×
100
NEW 101	if let Some((key, _)) = recv_tree.iter().find_map(\|entry\| {	×
NEW 102	let (key, value) = entry.ok()?;	×
NEW 103	let receiver: Receiver = serde_json::from_slice(&value).ok()?;	×
104
NEW 105	if receiver.pj_uri().extras.endpoint() == pj_url {	×
NEW 106	Some((key, value))	×
107	} else {
NEW 108	None	×
109	}
NEW 110	}) {	×
NEW 111	recv_tree.remove(key)?;	×
NEW 112	recv_tree.flush()?;	×
NEW 113	}	×
114
NEW 115	Ok(())	×
NEW 116	}	×
117
118	pub(crate) fn get_send_sessions(&self) -> Result<Vec<Sender>> {	1✔
119	let send_tree: Tree = self.0.open_tree("send_sessions")?;	1✔
120	let mut sessions = Vec::new();	1✔
121	for item in send_tree.iter() {	1✔
122	let (_, value) = item?;	×
123	let session: Sender = serde_json::from_slice(&value).map_err(Error::Deserialize)?;	×
124	sessions.push(session);	×
125	}
126	Ok(sessions)	1✔
127	}	1✔
128
129	pub(crate) fn get_send_session(&self, pj_url: &Url) -> Result<Option<Sender>> {	2✔
130	let send_tree = self.0.open_tree("send_sessions")?;	2✔
131	if let Some(val) = send_tree.get(pj_url.as_str())? {	2✔
132	let session: Sender = serde_json::from_slice(&val).map_err(Error::Deserialize)?;	1✔
133	Ok(Some(session))	1✔
134	} else {
135	Ok(None)	1✔
136	}
137	}	2✔
138
139	pub(crate) fn clear_send_session(&self, pj_url: &Url) -> Result<()> {	1✔
140	let send_tree: Tree = self.0.open_tree("send_sessions")?;	1✔
141	send_tree.remove(pj_url.as_str())?;	1✔
142	send_tree.flush()?;	1✔
143	Ok(())	1✔
144	}	1✔
145	}

payjoin / rust-payjoin / 14228368139

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous