gsdk 2.0.0

Rust SDK of the Gear network
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// Copyright (C) Gear Technologies Inc.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

//! This module provides useful functions for working with event stream.

use crate::{
    Error, Event, Result,
    gear::{gear, runtime_types::gear_common::event::DispatchStatus},
};
use futures::prelude::*;
use gear_core::ids::MessageId;
use parity_scale_codec::Decode;
use std::{
    collections::{HashMap, HashSet},
    pin::pin,
};

/// Extracts a reply on given message from a stream of events.
///
/// The reply is returned as bytes. If decoding the reply payload
/// is needed, see [`reply_on`].
pub async fn reply_bytes_on(
    message_id: MessageId,
    events: impl Stream<Item = Result<Event>>,
) -> Result<Result<Vec<u8>, Vec<u8>>> {
    let payloads = events
        .map(|event| {
            Ok::<_, Error>(
                if let Event::Gear(gear::Event::UserMessageSent { message, .. }) = event?
                    && let Some(details) = message.details()
                    && details.to_message_id() == message_id
                {
                    let payload = message.payload_bytes().to_vec();

                    if details.to_reply_code().is_success() {
                        Some(Ok(payload))
                    } else {
                        Some(Err(payload))
                    }
                } else {
                    None
                },
            )
        })
        .filter_map(|res| future::ready(res.transpose()));

    pin!(payloads)
        .next()
        .await
        .unwrap_or(Err(Error::EventNotFound))
}

/// Extracts a reply on given message from a stream of events.
///
/// The reply payload is decoded as `T` for success payload
/// and as [`String`] for error messages.
///
/// For more low-level variant of the function that doesn't do
/// decoding see [`reply_bytes_on`].
pub async fn reply_on<T: Decode>(
    message_id: MessageId,
    events: impl Stream<Item = Result<Event>>,
) -> Result<Result<T, String>> {
    Ok(match reply_bytes_on(message_id, events).await? {
        Ok(payload) => Ok(T::decode(&mut payload.as_slice())?),
        Err(payload) => Err(String::from_utf8(payload)?),
    })
}

/// Waits until the message with given ID is processed
/// and returns is [`DispatchStatus`].
pub async fn message_dispatch_status(
    message_id: MessageId,
    events: impl Stream<Item = Result<Event>>,
) -> Result<DispatchStatus> {
    let dispatch_statuses = events
        .map(|event| {
            Ok::<_, Error>(match event? {
                Event::Gear(gear::Event::MessagesDispatched { statuses, .. }) => statuses
                    .into_iter()
                    .find_map(|(mid, status)| (mid == message_id).then_some(status)),
                _ => None,
            })
        })
        .filter_map(|res| future::ready(res.transpose()));

    pin!(dispatch_statuses)
        .next()
        .await
        .unwrap_or(Err(Error::EventNotFound))
}

/// Waits until messages with given IDs are processed
/// and returns their [`DispatchStatus`]es.
pub async fn message_batch_dispatch_statuses(
    message_ids: impl IntoIterator<Item = MessageId>,
    events: impl Stream<Item = Result<Event>>,
) -> Result<HashMap<MessageId, DispatchStatus>> {
    let statuses = events
        .map(|event| {
            Ok::<_, Error>(
                stream::iter(match event? {
                    Event::Gear(gear::Event::MessagesDispatched { statuses, .. }) => {
                        Some(stream::iter(statuses).map(Ok::<_, Error>))
                    }
                    _ => None,
                })
                .map(Ok::<_, Error>),
            )
        })
        .try_flatten()
        .try_flatten();
    let mut statuses = pin!(statuses);

    let mut message_ids = HashSet::<MessageId>::from_iter(message_ids);
    let mut message_statuses = HashMap::new();

    while let Some((message_id, status)) = statuses.next().await.transpose()? {
        if message_ids.remove(&message_id) {
            message_statuses.insert(message_id, status);
        }

        if message_ids.is_empty() {
            return Ok(message_statuses);
        }
    }

    Err(Error::EventNotFound)
}