mi
384 lines
15 KiB
Python
384 lines
15 KiB
Python
import asyncio
|
|
import uuid
|
|
from datetime import UTC, datetime, timedelta
|
|
|
|
import httpx
|
|
import redis.asyncio as redis
|
|
import structlog
|
|
from sqlalchemy import delete, select
|
|
|
|
from app.db import (
|
|
Database,
|
|
DeliveryOutbox,
|
|
Dialog,
|
|
Message,
|
|
MessageAttachment,
|
|
SafetyTask,
|
|
UserIdentity,
|
|
)
|
|
from app.integrations import (
|
|
DependencyFailure,
|
|
OpenLinesClient,
|
|
S3Client,
|
|
SafetyClient,
|
|
fresh_openlines_payload,
|
|
)
|
|
from app.notification_models import ClientUploadDraft
|
|
from app.notification_service import expire_notifications
|
|
from app.realtime import RealtimeFanout
|
|
from app.services import load_settings, publish_dialog_status, publish_message_status
|
|
from app.settings import Settings, get_settings
|
|
|
|
log = structlog.get_logger()
|
|
|
|
|
|
async def delivery_once(
|
|
db: Database,
|
|
client: OpenLinesClient,
|
|
s3: S3Client,
|
|
fanout: RealtimeFanout,
|
|
settings: Settings,
|
|
worker_id: str,
|
|
batch_size: int = 20,
|
|
) -> int:
|
|
async with db.sessions() as session:
|
|
rows = (
|
|
(
|
|
await session.execute(
|
|
select(DeliveryOutbox)
|
|
.where(
|
|
DeliveryOutbox.status.in_(["pending", "retry"]),
|
|
DeliveryOutbox.next_attempt_at <= datetime.now(UTC),
|
|
)
|
|
.with_for_update(skip_locked=True)
|
|
.limit(batch_size)
|
|
)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
ids = [row.id for row in rows]
|
|
for row in rows:
|
|
row.status = "processing"
|
|
row.locked_at = datetime.now(UTC)
|
|
row.locked_by = worker_id
|
|
await session.commit()
|
|
for row_id in ids:
|
|
async with db.sessions() as session:
|
|
row = await session.get(DeliveryOutbox, row_id, with_for_update=True)
|
|
if row is None:
|
|
continue
|
|
message = None
|
|
dialog = None
|
|
try:
|
|
payload = await fresh_openlines_payload(row.payload_json, s3)
|
|
await client.send(row.message_id, payload, f"worker-{worker_id}")
|
|
row.status = "delivered"
|
|
message = await session.get(Message, row.message_id)
|
|
if message:
|
|
message.delivery_status = "delivered"
|
|
dialog = await session.get(Dialog, message.dialog_id)
|
|
if dialog:
|
|
dialog.status = "waiting_for_company"
|
|
dialog.last_message_at = datetime.now(UTC)
|
|
except DependencyFailure:
|
|
row.attempt_count += 1
|
|
row.status = "dead_letter" if row.attempt_count >= 12 else "retry"
|
|
row.next_attempt_at = datetime.now(UTC) + timedelta(
|
|
seconds=min(3600, 2**row.attempt_count)
|
|
)
|
|
row.last_error_code = "dependency_unavailable"
|
|
row.locked_at = None
|
|
row.locked_by = None
|
|
await session.commit()
|
|
if message:
|
|
await publish_message_status(fanout, message, settings)
|
|
if dialog:
|
|
await publish_dialog_status(fanout, dialog)
|
|
return len(ids)
|
|
|
|
|
|
async def safety_once(
|
|
db: Database,
|
|
safety: SafetyClient,
|
|
s3: S3Client,
|
|
fanout: RealtimeFanout,
|
|
settings: Settings,
|
|
worker_id: str,
|
|
batch_size: int = 20,
|
|
) -> int:
|
|
async with db.sessions() as session:
|
|
rows = (
|
|
(
|
|
await session.execute(
|
|
select(SafetyTask)
|
|
.where(
|
|
SafetyTask.status.in_(["polling", "failed"]),
|
|
SafetyTask.next_poll_at <= datetime.now(UTC),
|
|
SafetyTask.expires_at > datetime.now(UTC),
|
|
)
|
|
.with_for_update(skip_locked=True)
|
|
.limit(batch_size)
|
|
)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
ids = [row.id for row in rows]
|
|
for row in rows:
|
|
row.locked_at, row.locked_by = datetime.now(UTC), worker_id
|
|
await session.commit()
|
|
for task_id in ids:
|
|
async with db.sessions() as session:
|
|
task = await session.get(SafetyTask, task_id, with_for_update=True)
|
|
if task is None:
|
|
continue
|
|
message = None
|
|
try:
|
|
verdict = await safety.poll(task.poll_location, f"worker-{worker_id}")
|
|
message = await session.get(Message, task.message_id)
|
|
attachment = (
|
|
await session.get(MessageAttachment, task.attachment_id)
|
|
if task.attachment_id
|
|
else None
|
|
)
|
|
if verdict["_status"] == 200 and message:
|
|
message.safety_processing_mode = verdict["processing_mode"]
|
|
message.safety_config_version = verdict["config_version"]
|
|
message.safety_rules_version = verdict["rules_version"]
|
|
if attachment and attachment.quarantine_object_key:
|
|
destination = f"attachments/dialogs/{message.dialog_id}/{attachment.id}"
|
|
await s3.promote(
|
|
attachment.quarantine_object_key,
|
|
destination,
|
|
version_id=attachment.quarantine_version_id or "",
|
|
etag=attachment.quarantine_etag or "",
|
|
)
|
|
attachment.storage_bucket = s3.settings.selectel_s3_bucket_attachments
|
|
attachment.object_key = destination
|
|
attachment.quarantine_object_key = None
|
|
attachment.scan_status = (
|
|
"bypassed"
|
|
if verdict["processing_mode"] == "mock"
|
|
else "clean"
|
|
)
|
|
message.safety_status = "allowed"
|
|
task.status = "completed"
|
|
dialog = await session.get(Dialog, message.dialog_id)
|
|
user = (
|
|
await session.get(UserIdentity, dialog.user_id)
|
|
if dialog
|
|
else None
|
|
)
|
|
if dialog and user:
|
|
session.add(
|
|
DeliveryOutbox(
|
|
message_id=message.id,
|
|
external_chat_id=dialog.id,
|
|
payload_json={
|
|
"message_id": str(message.id),
|
|
"external_chat_id": str(dialog.id),
|
|
"occurred_at": message.occurred_at.isoformat(),
|
|
"user": {
|
|
"id": str(user.id),
|
|
"display_name": user.phone_number,
|
|
},
|
|
"message": {
|
|
"content_kind": message.content_kind,
|
|
"text": message.text,
|
|
"files": (
|
|
[{
|
|
"attachment_id": str(attachment.id),
|
|
"name": attachment.safe_file_name,
|
|
"mime_type": attachment.mime_type,
|
|
"size_bytes": attachment.size_bytes,
|
|
"_storage_bucket": attachment.storage_bucket,
|
|
"_object_key": attachment.object_key,
|
|
}]
|
|
if attachment
|
|
else []
|
|
),
|
|
},
|
|
},
|
|
next_attempt_at=datetime.now(UTC),
|
|
)
|
|
)
|
|
elif verdict["_status"] == 403 and message:
|
|
message.safety_processing_mode = verdict["processing_mode"]
|
|
message.safety_config_version = verdict["config_version"]
|
|
message.safety_rules_version = verdict["rules_version"]
|
|
message.text = ""
|
|
message.safety_status = "blocked"
|
|
message.delivery_status = "rejected"
|
|
if attachment and attachment.quarantine_object_key:
|
|
await s3.delete_quarantine(attachment.quarantine_object_key)
|
|
attachment.scan_status = "infected"
|
|
task.status = "completed"
|
|
else:
|
|
if verdict["_status"] == 202:
|
|
task.poll_location = verdict["_location"]
|
|
task.next_poll_at = datetime.now(UTC) + timedelta(seconds=2)
|
|
except DependencyFailure as exc:
|
|
task.attempt_count += 1
|
|
terminal = exc.terminal or (
|
|
exc.code == "task_not_found" and task.attempt_count >= 2
|
|
)
|
|
task.status = "terminal_failed" if terminal else "failed"
|
|
task.last_error_code = exc.code
|
|
if terminal and message:
|
|
message.delivery_status = "failed"
|
|
task.next_poll_at = datetime.now(UTC) + timedelta(
|
|
seconds=min(300, 2**task.attempt_count)
|
|
)
|
|
task.locked_at = None
|
|
task.locked_by = None
|
|
await session.commit()
|
|
if message:
|
|
await publish_message_status(fanout, message, settings)
|
|
return len(ids)
|
|
|
|
|
|
async def cleanup_once(db: Database, s3: S3Client, batch_size: int = 100) -> int:
|
|
async with db.sessions() as session:
|
|
rows = (
|
|
(
|
|
await session.execute(
|
|
select(MessageAttachment)
|
|
.where(
|
|
MessageAttachment.record_status == "A",
|
|
MessageAttachment.quarantine_object_key.is_not(None),
|
|
MessageAttachment.upload_expires_at < datetime.now(UTC),
|
|
MessageAttachment.message_id.is_(None),
|
|
)
|
|
.with_for_update(skip_locked=True)
|
|
.limit(batch_size)
|
|
)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
for row in rows:
|
|
if row.quarantine_object_key:
|
|
await s3.delete_quarantine(row.quarantine_object_key)
|
|
row.record_status = "D"
|
|
row.status_changed_at = datetime.now(UTC)
|
|
row.status_change_reason = "expired_quarantine_cleanup"
|
|
await session.commit()
|
|
return len(rows)
|
|
|
|
|
|
async def loop(kind: str) -> None:
|
|
settings = get_settings()
|
|
db = Database(settings.database_url)
|
|
http = httpx.AsyncClient()
|
|
safety = SafetyClient(settings, http)
|
|
openlines = OpenLinesClient(settings, http)
|
|
s3 = S3Client(settings)
|
|
redis_rt = redis.from_url(settings.redis_realtime_url, decode_responses=True)
|
|
fanout = RealtimeFanout(redis_rt)
|
|
worker_id = f"{kind}-{uuid.uuid4()}"
|
|
try:
|
|
while True:
|
|
count = 0
|
|
if kind == "delivery":
|
|
count = await delivery_once(db, openlines, s3, fanout, settings, worker_id)
|
|
elif kind == "safety":
|
|
count = await safety_once(db, safety, s3, fanout, settings, worker_id)
|
|
else:
|
|
count = await cleanup_once(db, s3)
|
|
if not count:
|
|
await asyncio.sleep(settings.worker_poll_interval_sec)
|
|
finally:
|
|
await http.aclose()
|
|
await redis_rt.aclose()
|
|
await db.close()
|
|
|
|
|
|
async def notification_expire_loop() -> None:
|
|
settings = get_settings()
|
|
db = Database(settings.database_url)
|
|
try:
|
|
while True:
|
|
async with db.sessions() as session:
|
|
snapshot = await load_settings(session)
|
|
run_at = snapshot.values["notification.expire_job.run_at"]
|
|
hour, minute = (int(value) for value in run_at.split(":", 1))
|
|
now = datetime.now(UTC)
|
|
target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
|
|
if target <= now:
|
|
target += timedelta(days=1)
|
|
await asyncio.sleep((target - now).total_seconds())
|
|
async with db.sessions() as session:
|
|
personal, guest = await expire_notifications(session)
|
|
log.info(
|
|
"notification.expired_batch",
|
|
personal_count=personal,
|
|
guest_count=guest,
|
|
)
|
|
finally:
|
|
await db.close()
|
|
|
|
|
|
async def notification_draft_cleanup_once(db: Database, s3: S3Client) -> int:
|
|
async with db.sessions() as session:
|
|
snapshot = await load_settings(session)
|
|
cutoff = datetime.now(UTC) - timedelta(
|
|
days=snapshot.integer("notification.upload_draft.ttl_days")
|
|
)
|
|
rows = (
|
|
(
|
|
await session.execute(
|
|
select(ClientUploadDraft)
|
|
.where(ClientUploadDraft.created_at < cutoff)
|
|
.with_for_update(skip_locked=True)
|
|
.limit(100)
|
|
)
|
|
)
|
|
.scalars()
|
|
.all()
|
|
)
|
|
for row in rows:
|
|
if row.state != "submitted":
|
|
if row.quarantine_object_key:
|
|
await s3.delete_quarantine(row.quarantine_object_key)
|
|
elif row.object_key:
|
|
await s3.delete(row.storage_bucket, row.object_key)
|
|
await session.execute(
|
|
delete(ClientUploadDraft).where(ClientUploadDraft.id == row.id)
|
|
)
|
|
await session.commit()
|
|
return len(rows)
|
|
|
|
|
|
async def notification_draft_cleanup_loop() -> None:
|
|
settings = get_settings()
|
|
db = Database(settings.database_url)
|
|
s3 = S3Client(settings)
|
|
try:
|
|
while True:
|
|
count = await notification_draft_cleanup_once(db, s3)
|
|
if count < 100:
|
|
await asyncio.sleep(86400)
|
|
finally:
|
|
await db.close()
|
|
|
|
|
|
def delivery_main() -> None:
|
|
asyncio.run(loop("delivery"))
|
|
|
|
|
|
def safety_main() -> None:
|
|
asyncio.run(loop("safety"))
|
|
|
|
|
|
def cleanup_main() -> None:
|
|
asyncio.run(loop("cleanup"))
|
|
|
|
|
|
def notification_expire_main() -> None:
|
|
asyncio.run(notification_expire_loop())
|
|
|
|
|
|
def notification_draft_cleanup_main() -> None:
|
|
asyncio.run(notification_draft_cleanup_loop())
|