Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

9.3 KB
Raw Blame
import asyncio
import logging
from collections.abc import Iterable
from dataclasses import asdict, dataclass

from aioapns import NotificationRequest
from django.utils.timezone import now as timezone_now
from firebase_admin import exceptions as firebase_exceptions
from firebase_admin import messaging as firebase_messaging
from firebase_admin.messaging import UnregisteredError as FCMUnregisteredError

from zerver.lib.devices import b64decode_token_id_base64, b64encode_token_id_int
from zerver.lib.push_notifications import (
    APNsPushRequest,
    FCMPushRequest,
    SendNotificationResponseData,
    fcm_app,
    get_apns_context,
    get_info_from_apns_result,
)
from zerver.models.realms import Realm
from zilencer.models import RemotePushDevice, RemoteRealm

logger = logging.getLogger(__name__)


@dataclass
class SentPushNotificationResult:
    successfully_sent_count: int
    delete_token_ids_base64: list[str]


def send_e2ee_push_notification_apple(
    apns_requests: list[NotificationRequest],
    apns_remote_push_devices: list[RemotePushDevice],
    log_context: str,
) -> SentPushNotificationResult:
    import aioapns

    successfully_sent_count = 0
    delete_token_ids_base64: list[str] = []
    apns_context = get_apns_context()

    if apns_context is None:
        logger.error(
            "APNs: Dropping push notifications since "
            "neither APNS_TOKEN_KEY_FILE nor APNS_CERT_FILE is set."
        )
        return SentPushNotificationResult(
            successfully_sent_count=successfully_sent_count,
            delete_token_ids_base64=delete_token_ids_base64,
        )

    async def send_all_notifications() -> Iterable[
        tuple[RemotePushDevice, aioapns.common.NotificationResult | BaseException]
    ]:
        results = await asyncio.gather(
            *(apns_context.send_notification(request) for request in apns_requests),
            return_exceptions=True,
        )
        return zip(apns_remote_push_devices, results, strict=False)

    results = apns_context.loop.run_until_complete(send_all_notifications())

    for remote_push_device, result in results:
        result_info = get_info_from_apns_result(
            result,
            remote_push_device,
            log_context % remote_push_device.token,
        )

        if result_info.successfully_sent:
            successfully_sent_count += 1
        elif result_info.delete_token_id_base64 is not None:
            remote_push_device.expired_time = timezone_now()
            remote_push_device.save(update_fields=["expired_time"])
            delete_token_ids_base64.append(result_info.delete_token_id_base64)

    return SentPushNotificationResult(
        successfully_sent_count=successfully_sent_count,
        delete_token_ids_base64=delete_token_ids_base64,
    )


def send_e2ee_push_notification_android(
    fcm_requests: list[firebase_messaging.Message],
    fcm_remote_push_devices: list[RemotePushDevice],
    log_context: str,
) -> SentPushNotificationResult:
    successfully_sent_count = 0
    delete_token_ids_base64: list[str] = []

    if fcm_app is None:
        logger.error("FCM: Dropping push notifications since ANDROID_FCM_CREDENTIALS_PATH is unset")
        return SentPushNotificationResult(
            successfully_sent_count=successfully_sent_count,
            delete_token_ids_base64=delete_token_ids_base64,
        )

    try:
        batch_response = firebase_messaging.send_each(fcm_requests, app=fcm_app)
    except firebase_exceptions.FirebaseError:
        logger.warning("Error while pushing to FCM", exc_info=True)
        return SentPushNotificationResult(
            successfully_sent_count=successfully_sent_count,
            delete_token_ids_base64=delete_token_ids_base64,
        )

    for idx, response in enumerate(batch_response.responses):
        # We enumerate to have idx to track which token the response
        # corresponds to. send_each() preserves the order of the messages,
        # so this works.

        remote_push_device = fcm_remote_push_devices[idx]
        token = remote_push_device.token

        if response.success:
            successfully_sent_count += 1
            logger.info(
                "FCM: Sent message with ID: %s %s", response.message_id, log_context % token
            )
        else:
            error = response.exception
            if isinstance(error, FCMUnregisteredError):
                remote_push_device.expired_time = timezone_now()
                remote_push_device.save(update_fields=["expired_time"])
                delete_token_ids_base64.append(b64encode_token_id_int(remote_push_device.token_id))

                logger.info("FCM: Removing %s due to %s", token, error.code)
            else:
                logger.warning(
                    "FCM: Delivery failed %s: %s:%s",
                    log_context % token,
                    error.__class__,
                    error,
                )

    return SentPushNotificationResult(
        successfully_sent_count=successfully_sent_count,
        delete_token_ids_base64=delete_token_ids_base64,
    )


def send_e2ee_push_notifications(
    push_requests: list[APNsPushRequest | FCMPushRequest],
    *,
    realm: Realm | None = None,
    remote_realm: RemoteRealm | None = None,
) -> SendNotificationResponseData:
    assert (realm is None) ^ (remote_realm is None)

    import aioapns

    token_ids_base64 = set()
    token_ids_int = set()
    for push_request in push_requests:
        token_ids_base64.add(push_request.token_id)
        token_ids_int.add(b64decode_token_id_base64(push_request.token_id))

    remote_push_devices = RemotePushDevice.objects.filter(
        token_id__in=token_ids_int,
        realm=realm,
        remote_realm=remote_realm,
        expired_time__isnull=True,
    )
    token_id_base64_to_remote_push_device = {
        b64encode_token_id_int(remote_push_device.token_id): remote_push_device
        for remote_push_device in remote_push_devices
    }
    unexpired_token_ids_base64 = set(token_id_base64_to_remote_push_device.keys())

    # Token IDs which should be deleted on server.
    # Either the token ID is invalid or the token
    # associated has been marked invalid/expired by APNs/FCM.
    delete_token_ids_base64 = list(
        filter(
            lambda token_id_base64: token_id_base64 not in unexpired_token_ids_base64,
            token_ids_base64,
        )
    )

    apns_requests = []
    apns_remote_push_devices: list[RemotePushDevice] = []

    fcm_requests = []
    fcm_remote_push_devices: list[RemotePushDevice] = []

    for push_request in push_requests:
        token_id_base64 = push_request.token_id
        if token_id_base64 not in unexpired_token_ids_base64:
            continue

        remote_push_device = token_id_base64_to_remote_push_device[token_id_base64]
        if remote_push_device.token_kind == RemotePushDevice.TokenKind.APNS:
            assert isinstance(push_request, APNsPushRequest)
            apns_requests.append(
                aioapns.NotificationRequest(
                    apns_topic=remote_push_device.ios_app_id,
                    device_token=remote_push_device.token,
                    message=asdict(push_request.payload),
                    priority=push_request.http_headers.apns_priority,
                    push_type=push_request.http_headers.apns_push_type,
                )
            )
            apns_remote_push_devices.append(remote_push_device)
        else:
            assert isinstance(push_request, FCMPushRequest)
            fcm_payload = dict(
                # FCM only allows string values, so we stringify push_key_id.
                push_key_id=str(push_request.payload.push_key_id),
                encrypted_data=push_request.payload.encrypted_data,
            )
            fcm_requests.append(
                firebase_messaging.Message(
                    data=fcm_payload,
                    token=remote_push_device.token,
                    android=firebase_messaging.AndroidConfig(priority=push_request.fcm_priority),
                )
            )
            fcm_remote_push_devices.append(remote_push_device)

    if realm is not None:
        log_context = f"to (realm={realm.uuid}, device=%s)"
    else:
        assert remote_realm is not None
        log_context = f"to (remote_realm={remote_realm.uuid}, device=%s)"

    apple_successfully_sent_count = 0
    if len(apns_requests) > 0:
        sent_push_notification_result = send_e2ee_push_notification_apple(
            apns_requests,
            apns_remote_push_devices,
            log_context,
        )
        apple_successfully_sent_count = sent_push_notification_result.successfully_sent_count
        delete_token_ids_base64.extend(sent_push_notification_result.delete_token_ids_base64)

    android_successfully_sent_count = 0
    if len(fcm_requests) > 0:
        sent_push_notification_result = send_e2ee_push_notification_android(
            fcm_requests,
            fcm_remote_push_devices,
            log_context,
        )
        android_successfully_sent_count = sent_push_notification_result.successfully_sent_count
        delete_token_ids_base64.extend(sent_push_notification_result.delete_token_ids_base64)

    return {
        "apple_successfully_sent_count": apple_successfully_sent_count,
        "android_successfully_sent_count": android_successfully_sent_count,
        "delete_token_ids": delete_token_ids_base64,
    }