2021-12-03 09:37:22 +00:00
//! Sbot type and associated methods.
2022-01-04 17:01:22 +00:00
use std ::fmt ::Debug ;
2021-12-02 17:48:16 +00:00
use async_std ::net ::TcpStream ;
2022-01-04 17:01:22 +00:00
use async_std ::stream ::{ Stream , StreamExt } ;
use async_stream ::stream ;
2021-12-02 17:55:31 +00:00
2021-12-02 17:48:16 +00:00
use kuska_handshake ::async_std ::BoxStream ;
use kuska_sodiumoxide ::crypto ::{ auth , sign ::ed25519 } ;
2021-12-02 17:55:31 +00:00
use kuska_ssb ::{
api ::{
2021-12-29 20:12:20 +00:00
dto ::{ CreateHistoryStreamIn } ,
2021-12-02 17:55:31 +00:00
ApiCaller ,
} ,
2021-12-29 16:38:03 +00:00
discovery , keystore ,
2021-12-02 17:55:31 +00:00
keystore ::OwnedIdentity ,
2022-01-04 17:01:22 +00:00
rpc ::{ RpcReader , RpcWriter , RecvMsg } ,
2021-12-02 17:48:16 +00:00
} ;
use crate ::error ::GolgiError ;
2021-12-30 01:51:17 +00:00
use crate ::messages ::{ SsbMessageKVT , SsbMessageContent , SsbMessageValue , SsbMessageContentType } ;
2021-12-02 17:48:16 +00:00
use crate ::utils ;
2021-12-29 20:12:20 +00:00
// re-export types from kuska
pub use kuska_ssb ::api ::dto ::content ::SubsetQuery ;
2022-01-04 17:01:22 +00:00
use kuska_ssb ::rpc ::RequestNo ;
2021-12-29 20:12:20 +00:00
2021-12-03 09:37:22 +00:00
/// The Scuttlebutt identity, keys and configuration parameters for connecting to a local sbot
/// instance, as well as handles for calling RPC methods and receiving responses.
2021-12-02 17:48:16 +00:00
pub struct Sbot {
id : String ,
public_key : ed25519 ::PublicKey ,
private_key : ed25519 ::SecretKey ,
address : String ,
// aka caps key (scuttleverse identifier)
network_id : auth ::Key ,
client : ApiCaller < TcpStream > ,
rpc_reader : RpcReader < TcpStream > ,
}
impl Sbot {
2021-12-03 09:37:22 +00:00
/// Initiate a connection with an sbot instance. Define the IP address, port and network key
/// for the sbot, then retrieve the public key, private key (secret) and identity from the
/// `.ssb-go/secret` file. Open a TCP stream to the sbot and perform the secret handshake. If successful, create a box stream and split it into a writer and reader. Return RPC handles to the sbot as part of the `struct` output.
2021-12-02 17:48:16 +00:00
pub async fn init ( ip_port : Option < String > , net_id : Option < String > ) -> Result < Sbot , GolgiError > {
2021-12-22 19:47:41 +00:00
let address = if ip_port . is_none ( ) {
" 127.0.0.1:8008 " . to_string ( )
2021-12-02 17:48:16 +00:00
} else {
2021-12-22 19:47:41 +00:00
ip_port . unwrap ( )
} ;
2021-12-02 17:48:16 +00:00
2021-12-22 19:47:41 +00:00
let network_id = if net_id . is_none ( ) {
discovery ::ssb_net_id ( )
2021-12-02 17:48:16 +00:00
} else {
2021-12-22 19:47:41 +00:00
auth ::Key ::from_slice ( & hex ::decode ( net_id . unwrap ( ) ) . unwrap ( ) ) . unwrap ( )
} ;
2021-12-02 17:48:16 +00:00
let OwnedIdentity { pk , sk , id } = keystore ::from_gosbot_local ( )
. await
. expect ( " couldn't read local secret " ) ;
let socket = TcpStream ::connect ( & address )
. await
. map_err ( | source | GolgiError ::Io {
source ,
context : " socket error; failed to initiate tcp stream connection " . to_string ( ) ,
} ) ? ;
let handshake = kuska_handshake ::async_std ::handshake_client (
& mut & socket ,
network_id . clone ( ) ,
pk ,
sk . clone ( ) ,
pk ,
)
. await
. map_err ( GolgiError ::Handshake ) ? ;
let ( box_stream_read , box_stream_write ) =
BoxStream ::from_handshake ( socket . clone ( ) , socket , handshake , 0x8000 ) . split_read_write ( ) ;
let rpc_reader = RpcReader ::new ( box_stream_read ) ;
let client = ApiCaller ::new ( RpcWriter ::new ( box_stream_write ) ) ;
Ok ( Self {
id ,
public_key : pk ,
private_key : sk ,
address ,
network_id ,
client ,
rpc_reader ,
} )
}
2022-01-05 13:50:57 +00:00
pub async fn get_rpc_reader ( & self , ip_port : Option < String > , net_id : Option < String > ) -> Result < RpcReader < TcpStream > , GolgiError > {
let address = if ip_port . is_none ( ) {
" 127.0.0.1:8008 " . to_string ( )
} else {
ip_port . unwrap ( )
} ;
let network_id = if net_id . is_none ( ) {
discovery ::ssb_net_id ( )
} else {
auth ::Key ::from_slice ( & hex ::decode ( net_id . unwrap ( ) ) . unwrap ( ) ) . unwrap ( )
} ;
let socket = TcpStream ::connect ( & address )
. await
. map_err ( | source | GolgiError ::Io {
source ,
context : " socket error; failed to initiate tcp stream connection " . to_string ( ) ,
} ) ? ;
let handshake = kuska_handshake ::async_std ::handshake_client (
& mut & socket ,
network_id . clone ( ) ,
self . public_key ,
self . private_key . clone ( ) ,
self . public_key ,
)
. await
. map_err ( GolgiError ::Handshake ) ? ;
let ( box_stream_read , box_stream_write ) =
BoxStream ::from_handshake ( socket . clone ( ) , socket , handshake , 0x8000 ) . split_read_write ( ) ;
let rpc_reader = RpcReader ::new ( box_stream_read ) ;
Ok ( rpc_reader )
}
2021-12-27 17:56:43 +00:00
/// Call the `partialReplication getSubset` RPC method and return a vector
/// of messages as KVTs (key, value, timestamp).
// TODO: add args for `descending` and `page` (max number of msgs in response)
2021-12-30 01:08:55 +00:00
pub async fn get_subset ( & mut self , query : SubsetQuery ) -> Result < Vec < SsbMessageKVT > , GolgiError > {
2021-12-27 17:56:43 +00:00
let req_id = self . client . getsubset_req_send ( query ) . await ? ;
2021-12-30 01:08:55 +00:00
utils ::get_source_until_eof ( & mut self . rpc_reader , req_id , utils ::kvt_res_parse ) . await
2021-12-27 17:56:43 +00:00
}
2021-12-03 09:37:22 +00:00
/// Call the `whoami` RPC method and return an `id`.
2021-12-02 17:48:16 +00:00
pub async fn whoami ( & mut self ) -> Result < String , GolgiError > {
let req_id = self . client . whoami_req_send ( ) . await ? ;
2021-12-29 16:31:53 +00:00
utils ::get_async ( & mut self . rpc_reader , req_id , utils ::string_res_parse ) . await
2021-12-02 17:48:16 +00:00
}
2021-12-03 09:37:22 +00:00
/// Call the `publish` RPC method and return a message reference.
///
/// # Arguments
///
2021-12-29 15:59:05 +00:00
/// * `msg` - A `SsbMessageContent` `enum` whose variants include `Pub`, `Post`, `Contact`, `About`,
2021-12-03 09:37:22 +00:00
/// `Channel` and `Vote`. See the `kuska_ssb` documentation for further details such as field
/// names and accepted values for each variant.
2021-12-29 15:59:05 +00:00
pub async fn publish ( & mut self , msg : SsbMessageContent ) -> Result < String , GolgiError > {
2021-12-03 09:37:22 +00:00
let req_id = self . client . publish_req_send ( msg ) . await ? ;
2021-12-29 16:31:53 +00:00
utils ::get_async ( & mut self . rpc_reader , req_id , utils ::string_res_parse ) . await
2021-12-03 09:37:22 +00:00
}
2021-12-22 19:47:41 +00:00
/// Wrapper for publish which constructs and publishes a post message appropriately from a string.
2021-12-22 19:42:01 +00:00
///
/// # Arguments
///
2021-12-24 15:34:07 +00:00
/// * `text` - A reference to a string slice which represents the text to be published in the post
2021-12-22 19:42:01 +00:00
pub async fn publish_post ( & mut self , text : & str ) -> Result < String , GolgiError > {
2021-12-29 15:59:05 +00:00
let msg = SsbMessageContent ::Post {
2021-12-27 17:56:43 +00:00
text : text . to_string ( ) ,
mentions : None ,
} ;
2021-12-22 19:42:01 +00:00
self . publish ( msg ) . await
}
2021-12-22 21:19:52 +00:00
/// Wrapper for publish which constructs and publishes an about description message appropriately from a string.
///
/// # Arguments
///
2021-12-24 15:34:07 +00:00
/// * `description` - A reference to a string slice which represents the text to be published as an about description.
2021-12-22 21:19:52 +00:00
pub async fn publish_description ( & mut self , description : & str ) -> Result < String , GolgiError > {
2021-12-29 15:59:05 +00:00
let msg = SsbMessageContent ::About {
2021-12-22 21:19:52 +00:00
about : self . id . to_string ( ) ,
name : None ,
title : None ,
branch : None ,
image : None ,
description : Some ( description . to_string ( ) ) ,
location : None ,
start_datetime : None ,
} ;
self . publish ( msg ) . await
}
2021-12-30 01:51:17 +00:00
/// Wrapper for publish which constructs and publishes an about name message appropriately from a string.
///
/// # Arguments
///
/// * `name` - A reference to a string slice which represents the text to be published as an about name.
pub async fn publish_name ( & mut self , name : & str ) -> Result < String , GolgiError > {
let msg = SsbMessageContent ::About {
about : self . id . to_string ( ) ,
name : Some ( name . to_string ( ) ) ,
title : None ,
branch : None ,
image : None ,
description : None ,
location : None ,
start_datetime : None ,
} ;
self . publish ( msg ) . await
}
2021-12-29 16:48:53 +00:00
2021-12-29 20:12:20 +00:00
/// Get the about messages for a particular user in order of recency.
2021-12-30 01:51:17 +00:00
pub async fn get_about_messages ( & mut self , ssb_id : & str ) -> Result < Vec < SsbMessageValue > , GolgiError > {
2021-12-29 20:12:20 +00:00
let query = SubsetQuery ::Author {
op : " author " . to_string ( ) ,
2021-12-30 01:51:17 +00:00
feed : ssb_id . to_string ( ) ,
2021-12-29 20:12:20 +00:00
} ;
2021-12-30 01:51:17 +00:00
let kvts : Vec < SsbMessageKVT > = self . get_subset ( query ) . await ? ;
2021-12-29 20:12:20 +00:00
let messages : Vec < SsbMessageValue > = kvts . into_iter ( ) . map ( | kvt | kvt . value ) . collect ( ) ;
// TODO: after fixing sbot regression,
// change this subset query to filter by type about in addition to author
// and remove this filter section
// filter down to about messages
let mut about_messages : Vec < SsbMessageValue > = messages . into_iter ( ) . filter ( | msg | {
msg . is_message_type ( SsbMessageContentType ::About )
} ) . collect ( ) ;
// TODO: use subset query to order messages instead of doing it this way
about_messages . sort_by ( | a , b | {
2021-12-30 01:51:17 +00:00
b . timestamp . partial_cmp ( & a . timestamp ) . unwrap ( )
2021-12-29 20:12:20 +00:00
} ) ;
// return about messages
Ok ( about_messages )
2021-12-29 16:48:53 +00:00
}
2021-12-30 01:51:17 +00:00
/// Get value of latest about message with given key from given user
pub async fn get_latest_about_message ( & mut self , ssb_id : & str , key : & str ) -> Result < Option < String > , GolgiError > {
// vector of about messages with most recent at the front of the vector
let about_messages = self . get_about_messages ( ssb_id ) . await ? ;
2021-12-30 18:35:39 +00:00
// iterate through the vector looking for most recent about message with the given key
let latest_about = about_messages
. iter ( )
// find the first msg that contains the field `key`
. find ( | msg | msg . content . get ( key ) . is_some ( ) )
// map the found msg (`Some(SsbMessageValue)`) to a `Some(Some(&Value))`
. map ( | msg | msg . content . get ( key ) )
// flatten `Some(Some(&Value))` into `Some(&Value)`
. flatten ( )
// map `Some(&Value)` to `Some(Some(&str))`
. map ( | msg_val | msg_val . as_str ( ) )
// flatten `Some(Some(&str))` to `Some(&str)`
. flatten ( )
// map `Some(&str))` to `Some(String)`
. map ( | msg_str | msg_str . to_string ( ) ) ;
// return value is either `Ok(Some(String))` or `Ok(None)`
Ok ( latest_about )
2021-12-30 01:51:17 +00:00
}
pub async fn get_name ( & mut self , ssb_id : & str ) -> Result < Option < String > , GolgiError > {
self . get_latest_about_message ( ssb_id , " name " ) . await
2021-12-29 16:48:53 +00:00
}
2021-12-30 02:03:06 +00:00
pub async fn get_description ( & mut self , ssb_id : & str ) -> Result < Option < String > , GolgiError > {
self . get_latest_about_message ( ssb_id , " description " ) . await
}
2022-01-04 19:09:49 +00:00
/// Call the `createHistoryStream` RPC method
/// and return a Stream of Result<SsbMessageValue, GolgiError>
2022-01-05 13:50:57 +00:00
pub async fn create_history_stream (
& mut self ,
2021-12-29 16:31:53 +00:00
id : String ,
2022-01-05 13:50:57 +00:00
) -> Result < impl Stream < Item = Result < SsbMessageValue , GolgiError > > , GolgiError > {
2021-12-02 17:48:16 +00:00
let args = CreateHistoryStreamIn ::new ( id ) ;
let req_id = self . client . create_history_stream_req_send ( & args ) . await ? ;
2022-01-05 13:50:57 +00:00
let mut rpc_reader = self . get_rpc_reader ( None , None ) . await . unwrap ( ) ;
let history_stream = Sbot ::get_source_stream ( rpc_reader , req_id , utils ::ssb_message_res_parse ) . await ;
2022-01-04 19:09:49 +00:00
Ok ( history_stream )
2021-12-02 17:48:16 +00:00
}
2022-01-04 17:01:22 +00:00
2022-01-04 19:09:49 +00:00
/// Takes in an rpc request number, and a handling function (parsing results of type T),
/// and produces an async_std::stream::Stream
/// of results of type T where the handling functions is called
/// on all rpc_reader responses which match the request number
///
/// # Arguments
///
/// * `req_no` - A `RequestNo` of the response to listen for
/// * `f` - A function which takes in an array of u8 and returns a Result<T, GolgiError>.
/// This is a function which parses the response from the RpcReader. T is a generic type,
/// so this parse function can return multiple possible types (String, json, custom struct etc.)
2022-01-05 13:50:57 +00:00
pub async fn get_source_stream < ' a , F , T > ( mut rpc_reader : RpcReader < TcpStream > , req_no : RequestNo , f : F ) -> impl Stream < Item = Result < T , GolgiError > >
2022-01-04 17:01:22 +00:00
where
2022-01-05 13:50:57 +00:00
F : Fn ( & [ u8 ] ) -> Result < T , GolgiError > ,
T : Debug + serde ::Deserialize < ' a > ,
2022-01-04 17:01:22 +00:00
{
2022-01-04 19:09:49 +00:00
// we use the async_stream::stream macro to allow for creating a stream which calls async functions
// see https://users.rust-lang.org/t/how-to-create-async-std-stream-which-calls-async-function-in-poll-next/69760
2022-01-05 13:50:57 +00:00
2022-01-04 19:09:49 +00:00
let source_stream = stream! {
2022-01-04 17:01:22 +00:00
loop {
2022-01-04 19:09:49 +00:00
// get the next message from the rpc_reader
2022-01-05 13:50:57 +00:00
let ( id , msg ) = rpc_reader . recv ( ) . await ? ;
2022-01-04 17:01:22 +00:00
let x : i32 = id . clone ( ) ;
2022-01-04 19:09:49 +00:00
// check if the next message from rpc_reader matches the req_no we are looking for
// if it matches, then this rpc response is for the given request
// and if it doesn't match, then we ignore it
2022-01-04 17:01:22 +00:00
if x = = req_no {
match msg {
RecvMsg ::RpcResponse ( _type , body ) = > {
2022-01-04 19:09:49 +00:00
// parse an item of type T from the message body using the provided
// function for parsing
2022-01-05 13:50:57 +00:00
let item = f ( & body ) ? ;
2022-01-04 19:09:49 +00:00
// return Ok(item) as the next value in the stream
yield Ok ( item )
2022-01-04 17:01:22 +00:00
}
RecvMsg ::ErrorResponse ( message ) = > {
2022-01-04 19:09:49 +00:00
// if an error is received
// return an Err(err) as the next value in the stream
2022-01-04 17:01:22 +00:00
yield Err ( GolgiError ::Sbot ( message . to_string ( ) ) ) ;
}
2022-01-04 19:09:49 +00:00
// if we find a CancelStreamResponse
// this is the end of the stream
2022-01-04 17:01:22 +00:00
RecvMsg ::CancelStreamRespose ( ) = > break ,
2022-01-04 19:09:49 +00:00
// if we find an unknown response, we just continue the loop
_ = > { }
2022-01-04 17:01:22 +00:00
}
}
}
} ;
2022-01-04 19:09:49 +00:00
// finally return the stream object
source_stream
2022-01-04 17:01:22 +00:00
}
2021-12-02 17:48:16 +00:00
}