130 lines
4.4 KiB
Rust
130 lines
4.4 KiB
Rust
use std::process;
|
|
|
|
use golgi::{
|
|
api::friends::{FriendsHops, RelationshipQuery},
|
|
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?;
|
|
|
|
// 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);
|
|
|
|
// Define IDs (public keys) to follow and block.
|
|
let to_follow = String::from("@5Pt3dKy2HTJ0mWuS78oIiklIX0gBz6BTfEnXsbvke9c=.ed25519");
|
|
let to_block = String::from("@7Y4nwfQmVtAilEzi5knXdS2gilW7cGKSHXdXoT086LM=.ed25519");
|
|
|
|
// Set the relationship of the local identity to the `to_follow` identity.
|
|
// In this case, the `set_relationship` method publishes a `contact`
|
|
// message which defines following as `true`.
|
|
// A message reference is returned for the published `contact` message.
|
|
let response = sbot_client
|
|
.set_relationship(&to_follow, Some(true), None)
|
|
.await?;
|
|
|
|
// Print the message reference to `stdout`.
|
|
println!("follow_response: {:?}", response);
|
|
|
|
// Set the relationship of the local identity to the `to_block` identity.
|
|
// In this case, the `set_relationship` method publishes a `contact`
|
|
// message which defines blocking as `true`.
|
|
// A message reference is returned for the published `contact` message.
|
|
let response = sbot_client
|
|
.set_relationship(&to_block, None, Some(true))
|
|
.await?;
|
|
|
|
// Print the message reference to `stdout`.
|
|
println!("follow_response: {:?}", response);
|
|
|
|
// Golgi also exposes convenience methods for following and blocking.
|
|
// Here is an example of a simpler way to follow an identity.
|
|
let _follow_response = sbot_client.follow(&to_follow).await?;
|
|
|
|
// Blocking can be achieved in a similar fashion.
|
|
let _block_response = sbot_client.block(&to_block).await?;
|
|
|
|
// Get a list of peers within 0 hops of the local identity.
|
|
// This returns a list of peers whom we follow.
|
|
// If `max` is set to 1, the list will include the peers we follow plus
|
|
// the peers that they follow.
|
|
let follows = sbot_client
|
|
.friends_hops(FriendsHops {
|
|
max: 0,
|
|
start: None,
|
|
// The `reverse` parameter is not currently implemented in `go-sbot`.
|
|
reverse: Some(false),
|
|
})
|
|
.await?;
|
|
|
|
// Print the list of peers to `stdout`.
|
|
println!("follows: {:?}", follows);
|
|
|
|
// Determine if an identity (`source`) is following a second identity (`dest`).
|
|
// This method will return `true` or `false`.
|
|
let mref = sbot_client
|
|
.friends_is_following(RelationshipQuery {
|
|
source: id.clone(),
|
|
dest: to_follow.clone(),
|
|
})
|
|
.await?;
|
|
|
|
// Print the follow status to `stdout`.
|
|
println!("isfollowingmref: {}", mref);
|
|
|
|
// Determine if an identity (`source`) is blocking a second identity (`dest`).
|
|
let mref = sbot_client
|
|
.friends_is_blocking(RelationshipQuery {
|
|
source: id.clone(),
|
|
dest: to_block.clone(),
|
|
})
|
|
.await?;
|
|
|
|
// Print the block status to `stdout`.
|
|
println!("isblockingmref: {}", mref);
|
|
|
|
let mref = sbot_client
|
|
.friends_is_blocking(RelationshipQuery {
|
|
source: id.clone(),
|
|
dest: to_follow,
|
|
})
|
|
.await?;
|
|
|
|
// Output should be `false`.
|
|
println!("isblockingmref(should be false): {}", mref);
|
|
|
|
let mref = sbot_client
|
|
.friends_is_following(RelationshipQuery {
|
|
source: id,
|
|
dest: to_block.clone(),
|
|
})
|
|
.await?;
|
|
|
|
// Output should be `false`.
|
|
println!("isfollowingmref(should be false): {}", mref);
|
|
|
|
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);
|
|
}
|
|
}
|