Struct SessionConfig 

pub struct SessionConfig { /* private fields */ }

One Grok Bot web session, ready to register. Built from the host environment (SessionConfig::from_env) or from the same fields the host would have injected. The nick is nick_from_display_name of bot_name. Local grok CLI sessions do not use this type.

Implementations

impl SessionConfig

pub fn new( homeserver_url: impl Into<String>, bot_name: &str, session_id: impl Into<String>, store_root: impl Into<PathBuf>, device_token: Option<String>, ) -> Result<Self, ShellError>

bot_name is the display name (Alice, Привет мир), not a nick.

Examples found in repository

examples/wake_test_sender.rs (lines 40-46)

fn main() {
    let homeserver = std::env::var("M4A_HOMESERVER_URL")
        .unwrap_or_else(|_| fail("env", "M4A_HOMESERVER_URL is not set"));
    let target = std::env::var("M4A_TEST_TARGET").unwrap_or_else(|_| "alice".to_string());
    let wait_secs: u64 = std::env::var("M4A_TEST_WAIT_SECS")
        .ok()
        .and_then(|value| value.parse().ok())
        .unwrap_or(90);
    let stamp = now_ms() / 1000;
    let session_id = format!("wake-test-sender-{stamp}");
    let store_root = std::env::temp_dir().join(format!("m4a-wake-test-{stamp}"));
    let config = SessionConfig::new(
        &homeserver,
        "WakeTestSender",
        &session_id,
        &store_root,
        None,
    )
    .unwrap_or_else(|err| fail("config", err));
    let mut store = OpenedStore::connect(&config).unwrap_or_else(|err| fail("register", err));
    println!("registered nick={} session={session_id}", config.nick());
    let room_id = store
        .ensure_dm(&target, now_ms())
        .unwrap_or_else(|err| fail("ensure_dm", err));
    println!("dm room={room_id}");
    let started = Instant::now();
    let peer = store
        .find_nick(&target, now_ms())
        .unwrap_or_else(|err| fail("find_nick", err))
        .user_id;
    loop {
        if store.member_joined(&room_id, &peer) {
            break;
        }
        if started.elapsed().as_secs() >= wait_secs {
            fail(
                "join wait",
                format!("{target} did not join in {wait_secs}s"),
            );
        }
        store
            .drive(now_ms(), false)
            .unwrap_or_else(|err| fail("drive", err));
        std::thread::sleep(Duration::from_millis(500));
    }
    println!("peer joined user={peer}");
    let encrypted = store
        .rooms()
        .into_iter()
        .any(|room| room.room_id == room_id && room.encrypted);
    println!("room encrypted={encrypted}");
    let text = format!("wake test {stamp}");
    store
        .write_to_nick(&target, &text, now_ms())
        .unwrap_or_else(|err| fail("write_to_nick", err));
    let event_id = store
        .texts()
        .into_iter()
        .find(|row| row.room_id == room_id && row.body == text)
        .and_then(|row| row.event_id)
        .unwrap_or_default();
    println!("sent event={event_id}");
}

pub fn new_product( product_url: impl Into<String>, nick: &str, secret: ProductSecret, session_id: impl Into<String>, store_root: impl Into<PathBuf>, ) -> Result<Self, ShellError>

Product-session mode: log in at the product server product_url as nick and talk to the messenger only through its proxy. The nick is the product nick; the session id still names the local store.

pub fn from_env() -> Result<Self, ShellError>

Host environment for a Grok Bot web session.

Required: HOMESERVER_URL_ENV or homeserver_url in toml, BOT_NAME_ENV (display name), SESSION_ID_ENV, STORE_ROOT_ENV. Optional: DEVICE_TOKEN_ENV. M4A_NICK, ROUTINE_URL_ENV, and LEADER_SOCK_ENV are not read. Wake is chosen by the open path.

pub fn is_product(&self) -> bool

True in product-session mode.

pub fn nick(&self) -> &str

Derived nick. Not the display name.

Examples found in repository

examples/wake_test_sender.rs (line 49)

fn main() {
    let homeserver = std::env::var("M4A_HOMESERVER_URL")
        .unwrap_or_else(|_| fail("env", "M4A_HOMESERVER_URL is not set"));
    let target = std::env::var("M4A_TEST_TARGET").unwrap_or_else(|_| "alice".to_string());
    let wait_secs: u64 = std::env::var("M4A_TEST_WAIT_SECS")
        .ok()
        .and_then(|value| value.parse().ok())
        .unwrap_or(90);
    let stamp = now_ms() / 1000;
    let session_id = format!("wake-test-sender-{stamp}");
    let store_root = std::env::temp_dir().join(format!("m4a-wake-test-{stamp}"));
    let config = SessionConfig::new(
        &homeserver,
        "WakeTestSender",
        &session_id,
        &store_root,
        None,
    )
    .unwrap_or_else(|err| fail("config", err));
    let mut store = OpenedStore::connect(&config).unwrap_or_else(|err| fail("register", err));
    println!("registered nick={} session={session_id}", config.nick());
    let room_id = store
        .ensure_dm(&target, now_ms())
        .unwrap_or_else(|err| fail("ensure_dm", err));
    println!("dm room={room_id}");
    let started = Instant::now();
    let peer = store
        .find_nick(&target, now_ms())
        .unwrap_or_else(|err| fail("find_nick", err))
        .user_id;
    loop {
        if store.member_joined(&room_id, &peer) {
            break;
        }
        if started.elapsed().as_secs() >= wait_secs {
            fail(
                "join wait",
                format!("{target} did not join in {wait_secs}s"),
            );
        }
        store
            .drive(now_ms(), false)
            .unwrap_or_else(|err| fail("drive", err));
        std::thread::sleep(Duration::from_millis(500));
    }
    println!("peer joined user={peer}");
    let encrypted = store
        .rooms()
        .into_iter()
        .any(|room| room.room_id == room_id && room.encrypted);
    println!("room encrypted={encrypted}");
    let text = format!("wake test {stamp}");
    store
        .write_to_nick(&target, &text, now_ms())
        .unwrap_or_else(|err| fail("write_to_nick", err));
    let event_id = store
        .texts()
        .into_iter()
        .find(|row| row.room_id == room_id && row.body == text)
        .and_then(|row| row.event_id)
        .unwrap_or_default();
    println!("sent event={event_id}");
}

pub fn homeserver_url(&self) -> &str

Homeserver origin this session will register against.

pub fn store_dir(&self) -> PathBuf

session_store_dir for this session under the configured root.

pub fn session_id(&self) -> &str

Session id the host assigned. Not a secret.

Trait Implementations

impl Debug for SessionConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.