100 lines
3.4 KiB
Rust
100 lines
3.4 KiB
Rust
use std::process;
|
|
|
|
use golgi::{messages::SsbMessageContent, sbot::Keystore, 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 initialise a connection to an sbot instance using the
|
|
// secret file at the Patchwork path and the default IP address, port
|
|
// and network key (aka. capabilities key).
|
|
let mut sbot_client = Sbot::init(Keystore::Patchwork, None, None).await?;
|
|
|
|
// Alternatively, we could specify a non-standard IP and port.
|
|
// let ip_port = "127.0.0.1:8021".to_string();
|
|
// let mut sbot_client = Sbot::init(Some(ip_port), 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);
|
|
|
|
// Compose an SSB `about` message type.
|
|
// The `SsbMessageContent` type has many variants and allows for a high
|
|
// degree of control when creating messages.
|
|
let name = SsbMessageContent::About {
|
|
about: id.clone(),
|
|
name: Some("golgi".to_string()),
|
|
title: None,
|
|
branch: None,
|
|
image: None,
|
|
description: None,
|
|
location: None,
|
|
start_datetime: None,
|
|
};
|
|
|
|
// Publish the name message. The `publish` method returns a reference to
|
|
// the published message.
|
|
let name_msg_ref = sbot_client.publish(name).await?;
|
|
|
|
// Print the message reference to `stdout`.
|
|
println!("name_msg_ref: {}", name_msg_ref);
|
|
|
|
// Compose an SSB `post` message type.
|
|
let post = SsbMessageContent::Post {
|
|
text: "golgi go womp womp".to_string(),
|
|
mentions: None,
|
|
};
|
|
|
|
// Publish the post.
|
|
let post_msg_ref = sbot_client.publish(post).await?;
|
|
|
|
// Print the post reference to `stdout`.
|
|
println!("post_msg_ref: {}", post_msg_ref);
|
|
|
|
// Golgi also exposes convenience methods for some of the most common
|
|
// message types. Here we see an example of a convenience method for
|
|
// posting a description message. The description is for the local
|
|
// identity, ie. we are publishing this about "ourself".
|
|
let post_msg_ref = sbot_client
|
|
.publish_description("this is a description")
|
|
.await?;
|
|
|
|
// Print the description message reference to `stdout`.
|
|
println!("description: {}", post_msg_ref);
|
|
|
|
let author: String = id.clone();
|
|
println!("author: {:?}", author);
|
|
|
|
// Retrieve the description for the given public key (identity).
|
|
let description = sbot_client.get_description(&author).await?;
|
|
|
|
// Print the description to `stdout`.
|
|
println!("found description: {:?}", description);
|
|
|
|
// Compose and publish another `post` message type.
|
|
let post = SsbMessageContent::Post {
|
|
text: "golgi go womp womp2".to_string(),
|
|
mentions: None,
|
|
};
|
|
|
|
let post_msg_ref = sbot_client.publish(post).await?;
|
|
println!("post_msg_ref2: {}", post_msg_ref);
|
|
|
|
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);
|
|
}
|
|
}
|