126 lines
4.0 KiB
Rust
126 lines
4.0 KiB
Rust
use std::process;
|
|
|
|
use async_std::stream::StreamExt;
|
|
use futures::TryStreamExt;
|
|
|
|
use golgi::{
|
|
messages::{SsbMessageContentType, SsbMessageValue},
|
|
GolgiError, Sbot,
|
|
};
|
|
|
|
// Golgi is an asynchronous library so we must call it from within an
|
|
// async function. The `GolgiError` type encapsulates all possible
|
|
// error variants for the library.
|
|
async fn run() -> Result<(), GolgiError> {
|
|
// Attempt to connect to an sbot instance using the default IP address,
|
|
// port and network key (aka. capabilities key).
|
|
let mut sbot_client = Sbot::init(None, None).await?;
|
|
|
|
// Call the `whoami` RPC method to retrieve the public key for the sbot
|
|
// identity. This is our 'local' public key.
|
|
let id = sbot_client.whoami().await?;
|
|
|
|
// Print the public key (identity) to `stdout`.
|
|
println!("whoami: {}", id);
|
|
|
|
let author = id.clone();
|
|
|
|
// Create an ordered stream of all messages authored by the `author`
|
|
// identity.
|
|
let history_stream = sbot_client
|
|
.create_history_stream(author.to_string())
|
|
.await?;
|
|
|
|
// Pin the stream to the stack to allow polling of the `future`.
|
|
futures::pin_mut!(history_stream);
|
|
|
|
println!("looping through stream");
|
|
|
|
// Iterate through each element in the stream and match on the `Result`.
|
|
// In this case, each element has type `Result<SsbMessageValue, GolgiError>`.
|
|
while let Some(res) = history_stream.next().await {
|
|
match res {
|
|
Ok(value) => {
|
|
// Print the `SsbMessageValue` of this element to `stdout`.
|
|
println!("value: {:?}", value);
|
|
}
|
|
Err(err) => {
|
|
// Print the `GolgiError` of this element to `stderr`.
|
|
eprintln!("err: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
println!("reached end of stream");
|
|
|
|
// Create an ordered stream of all messages authored by the `author`
|
|
// identity.
|
|
let history_stream = sbot_client
|
|
.create_history_stream(author.to_string())
|
|
.await?;
|
|
|
|
// Collect the stream elements into a `Vec<SsbMessageValue>` using
|
|
// `try_collect`. A `GolgiError` will be returned from the `run`
|
|
// function if any element contains an error.
|
|
let results: Vec<SsbMessageValue> = history_stream.try_collect().await?;
|
|
|
|
// Loop through the `SsbMessageValue` elements, printing each one
|
|
// to `stdout`.
|
|
for x in results {
|
|
println!("x: {:?}", x);
|
|
}
|
|
|
|
// Create an ordered stream of all messages authored by the `author`
|
|
// identity.
|
|
let history_stream = sbot_client
|
|
.create_history_stream(author.to_string())
|
|
.await?;
|
|
|
|
// Iterate through the elements in the stream and use `map` to convert
|
|
// each `SsbMessageValue` element into a tuple of
|
|
// `(String, SsbMessageContentType)`. This is an example of stream
|
|
// conversion.
|
|
let type_stream = history_stream.map(|msg| match msg {
|
|
Ok(val) => {
|
|
let message_type = val.get_message_type()?;
|
|
let tuple: (String, SsbMessageContentType) = (val.signature, message_type);
|
|
Ok(tuple)
|
|
}
|
|
Err(err) => Err(err),
|
|
});
|
|
|
|
// Pin the stream to the stack to allow polling of the `future`.
|
|
futures::pin_mut!(type_stream);
|
|
|
|
println!("looping through type stream");
|
|
|
|
// Iterate through each element in the stream and match on the `Result`.
|
|
// In this case, each element has type
|
|
// `Result<(String, SsbMessageContentType), GolgiError>`.
|
|
while let Some(res) = type_stream.next().await {
|
|
match res {
|
|
Ok(value) => {
|
|
println!("value: {:?}", value);
|
|
}
|
|
Err(err) => {
|
|
println!("err: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
println!("reached end of type stream");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// Enable an async main function and execute the `run()` function,
|
|
// catching any errors and printing them to `stderr` before exiting the
|
|
// process.
|
|
#[async_std::main]
|
|
async fn main() {
|
|
if let Err(e) = run().await {
|
|
eprintln!("Application error: {}", e);
|
|
process::exit(1);
|
|
}
|
|
}
|