Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.5 KB
Raw Blame
use super::redis::post_message;
use crate::config::Config;
use crate::constants::DEFAULT_TIMEOUT_THRESHOLD;
use crate::context::ApiContext;
use crate::model::connection::StoredConnectionEntity;
use crate::model::message::Message;
use crate::model::sender::MessageReceipt;
use crate::service::connection::SendOutcome;
use crate::service::redis::MessageWithConnection;
use anyhow::Result;
use futures::future::join_all;
use model_entity::Entity;
use redis::aio::MultiplexedConnection;
use std::collections::HashMap;
use std::time::Instant;

pub struct Delivery {
    pub user_id: String,
    pub active: bool,
}

#[tracing::instrument(skip(ctx, redis_connection, message), err)]
pub async fn send_message_to_entity<Ctx>(
    ctx: Ctx,
    entity: &Entity<'_>,
    message: Message,
    redis_connection: MultiplexedConnection,
) -> Result<Vec<MessageReceipt>>
where
    Ctx: AsRef<ApiContext> + AsRef<Config> + Copy,
{
    tracing::trace!("sending message to entity");
    let api_context: &ApiContext = ctx.as_ref();

    let instant = Instant::now();
    let connections = api_context
        .connection_manager
        .get_entries_by_entity(entity)
        .await?;

    tracing::trace!(
        "fetched {} connections in {:?}",
        connections.len(),
        instant.elapsed()
    );

    tracing::trace!("sending message to {} connections", connections.len());

    let local_connections: Vec<&StoredConnectionEntity> = connections
        .iter()
        .filter(|connection| {
            api_context
                .connection_manager
                .has_connection(&connection.connection_id)
        })
        .collect();

    let remote_connections: Vec<&StoredConnectionEntity> = connections
        .iter()
        .filter(|connection| {
            !api_context
                .connection_manager
                .has_connection(&connection.connection_id)
        })
        .collect();

    Ok(send_messages_to_connections(
        api_context,
        local_connections,
        remote_connections,
        message,
        redis_connection,
    )
    .await)
}

#[tracing::instrument(
    skip_all,
    fields(
        local_connection_count = local_connections.len(),
        remote_connection_count = remote_connections.len(),
    )
)]
async fn send_messages_to_connections(
    api_context: &ApiContext,
    local_connections: Vec<&StoredConnectionEntity>,
    remote_connections: Vec<&StoredConnectionEntity>,
    message: Message,
    redis_connection: MultiplexedConnection,
) -> Vec<MessageReceipt> {
    let local_send_futures = local_connections.into_iter().map(|connection| {
        let message = message.clone();

        async move {
            let instant = Instant::now();
            let active = matches!(
                api_context
                    .connection_manager
                    .send_message(connection.connection_id.as_str(), message.clone())
                    .await,
                Ok(SendOutcome::Queued)
            ) && connection.is_active_in_threshold(Some(DEFAULT_TIMEOUT_THRESHOLD));

            tracing::trace!(
                "sent message to connection directly in {:?}",
                instant.elapsed()
            );

            let delivery = Delivery {
                user_id: connection.user_id.clone(),
                active,
            };

            Ok::<Delivery, anyhow::Error>(delivery)
        }
    });

    let remote_send_futures = remote_connections.into_iter().map(|connection| {
        let message = message.clone();
        let redis_connection = redis_connection.clone();
        async move {
            let instant = Instant::now();
            let active = connection.is_active_in_threshold(Some(DEFAULT_TIMEOUT_THRESHOLD));

            post_message(
                redis_connection,
                MessageWithConnection {
                    message: message.clone(),
                    connection_id: connection.connection_id.clone(),
                },
            )
            .await
            .inspect_err(|e| {
                tracing::error!(error=?e, "failed to publish message to redis");
            })?;

            tracing::trace!(
                "sent message to connection through redis in {:?}",
                instant.elapsed()
            );

            let delivery = Delivery {
                user_id: connection.user_id.clone(),
                active,
            };

            Ok::<Delivery, anyhow::Error>(delivery)
        }
    });

    // Independent per connection, so they are joined rather than tried: one
    // connection refusing a message is now an ordinary outcome (a saturated
    // queue is ejected), and it must not cancel delivery to the healthy
    // connections beside it or discard the receipts they produced.
    let local_results = join_all(local_send_futures).await;
    let remote_results = join_all(remote_send_futures).await;

    let mut receipts: HashMap<String, MessageReceipt> = HashMap::new();

    for delivery in local_results
        .into_iter()
        .chain(remote_results.into_iter())
        .filter_map(std::result::Result::ok)
    {
        if let Some(receipt) = receipts.get_mut(&delivery.user_id) {
            receipt.delivery_count += 1;
            receipt.active = receipt.active || delivery.active;
        } else {
            receipts.insert(
                delivery.user_id.clone(),
                MessageReceipt {
                    user_id: delivery.user_id,
                    delivery_count: 1,
                    active: delivery.active,
                },
            );
        }
    }

    receipts.into_values().collect()
}