aa-killtracker 0.17.0__tar.gz → 1.0.0a1__tar.gz

{aa_killtracker-0.17.0 → aa_killtracker-1.0.0a1}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: aa-killtracker
-Version: 0.17.0
+Version: 1.0.0a1
 Summary: An app for running killmail trackers with Alliance Auth and Discord.
 Author-email: Erik Kalkoken <kalkoken87@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
-Classifier: Framework :: Django :: 4.0
 Classifier: Framework :: Django :: 4.2
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: MIT License
@@ -17,15 +16,16 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 License-File: LICENSE
-Requires-Dist: allianceauth-app-utils>=1.19.0
-Requires-Dist: allianceauth>=3
+Requires-Dist: allianceauth-app-utils>=1.26
+Requires-Dist: allianceauth>=4,<5
 Requires-Dist: dacite
-Requires-Dist: dhooks-lite>=1.0
-Requires-Dist: django-eveuniverse>=1.3
-Requires-Dist: redis-simple-mq>=0.5
+Requires-Dist: dhooks-lite>=1.1
+Requires-Dist: django-eveuniverse>=1.5
+Requires-Dist: redis-simple-mq>=1.0
 Project-URL: Home, https://gitlab.com/ErikKalkoken/aa-killtracker
 
 # Killtracker

{aa_killtracker-0.17.0 → aa_killtracker-1.0.0a1}/killtracker/__init__.py

@@ -3,7 +3,7 @@
 # pylint: disable = invalid-name
 default_app_config = "killtracker.apps.KillmailsConfig"
 
-__version__ = "0.17.0"
+__version__ = "1.0.0a1"
 __title__ = "Killtracker"
 
 APP_NAME = "aa-killtracker"

{aa_killtracker-0.17.0 → aa_killtracker-1.0.0a1}/killtracker/admin.py

@@ -4,16 +4,21 @@
 
 
 from django.contrib import admin
+from django.db.models import QuerySet
 from django.http import HttpResponseRedirect
 from django.shortcuts import render
 from django.utils.safestring import mark_safe
 
 from allianceauth import NAME as site_header
 
-from . import tasks
-from .core.killmails import Killmail
-from .forms import TrackerAdminForm, TrackerAdminKillmailIdForm, field_nice_display
-from .models import EveKillmail, EveKillmailAttacker, Tracker, Webhook
+from killtracker import tasks
+from killtracker.core.zkb import Killmail
+from killtracker.forms import (
+    TrackerAdminForm,
+    TrackerAdminKillmailIdForm,
+    field_nice_display,
+)
+from killtracker.models import EveKillmail, EveKillmailAttacker, Tracker, Webhook
 
 
 class EveKillmailAttackerInline(admin.TabularInline):
@@ -46,17 +51,17 @@ class WebhookAdmin(admin.ModelAdmin):
     list_filter = ("is_enabled",)
     ordering = ("name",)
 
-    def _messages_in_queue(self, obj):
-        return obj.main_queue.size()
+    def _messages_in_queue(self, obj: Webhook):
+        return obj.messages_queued()
 
     actions = ["send_test_message", "purge_messages"]
 
     @admin.display(description="Purge queued messages of selected webhooks")
-    def purge_messages(self, request, queryset):
+    def purge_messages(self, request, queryset: QuerySet[Webhook]):
         actions_count = 0
         killmails_deleted = 0
         for webhook in queryset:
-            killmails_deleted += webhook.main_queue.clear()
+            killmails_deleted += webhook.delete_queued_messages()
             actions_count += 1
         self.message_user(
             request,

{aa_killtracker-0.17.0 → aa_killtracker-1.0.0a1}/killtracker/app_settings.py

@@ -6,20 +6,15 @@ KILLTRACKER_REDISQ_LOCK_TIMEOUT = clean_setting("KILLTRACKER_REDISQ_LOCK_TIMEOUT
 """Timeout for lock to ensure atomic access to ZKB RedisQ."""
 
 KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER = clean_setting(
-    "KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER", 60
+    "KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER", 600
 )
 """Ignore killmails that are older than the given number in minutes
 sometimes killmails appear belated on ZKB,
 this feature ensures they don't create new alerts.
 """
 
-KILLTRACKER_MAX_KILLMAILS_PER_RUN = clean_setting(
-    "KILLTRACKER_MAX_KILLMAILS_PER_RUN", 100
-)
-"""Maximum number of killmails retrieved from ZKB by task run."""
-
 KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS = clean_setting(
-    "KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS", 30
+    "KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS", default_value=30, min_value=0
 )
 """Killmails older than set number of days will be purged from the database.
 If you want to keep all killmails set this to 0.
@@ -62,11 +57,14 @@ when creating trackers.
 #####################
 # INTERNAL SETTINGS
 
-KILLTRACKER_REDISQ_TTW = clean_setting("KILLTRACKER_REDISQ_TTW", 5)
+KILLTRACKER_REDISQ_TTW = clean_setting("KILLTRACKER_REDISQ_TTW", 1)
 """Max duration to wait for new killmails from redisq in seconds."""
 
 KILLTRACKER_TASKS_TIMEOUT = clean_setting("KILLTRACKER_TASKS_TIMEOUT", 1_800)
-"""Tasks hard timeout."""
+"""Tasks hard timeout in seconds."""
+
+KILLTRACKER_RUN_TIMEOUT = clean_setting("KILLTRACKER_RUN_TIMEOUT", 55)
+"""Timeout for killtracker run in seconds."""
 
 KILLTRACKER_DISCORD_SEND_DELAY = clean_setting(
     "KILLTRACKER_DISCORD_SEND_DELAY", default_value=2, min_value=1, max_value=900
@@ -100,9 +98,21 @@ KILLTRACKER_STORAGE_KILLMAILS_LIFETIME = clean_setting(
 )
 """Max lifetime of killmails in temporary storage in seconds."""
 
-KILLTRACKER_ZKB_REQUEST_DELAY = clean_setting("KILLTRACKER_ZKB_REQUEST_DELAY", 500)
+KILLTRACKER_ZKB_REQUEST_DELAY = clean_setting(
+    "KILLTRACKER_ZKB_REQUEST_DELAY", default_value=500, min_value=500
+)
 """Delay between subsequent calls to ZKB API in milliseconds.
 
 This delay ensures the app does not breach the CloudFlare rate limit of currently
 two (2) requests per second per IP address.
 """
+
+KILLTRACKER_MAX_KILLMAILS_PER_RUN = clean_setting(
+    "KILLTRACKER_MAX_KILLMAILS_PER_RUN", default_value=500, min_value=1
+)
+"""Maximum number of killmails retrieved from ZKB by task run."""
+
+KILLTRACKER_MAX_MESSAGES_SENT_PER_RUN = clean_setting(
+    "KILLTRACKER_MAX_MESSAGES_SENT_PER_RUN", default_value=10, min_value=1
+)
+"""Maximum number of messages processed per task run."""

{aa_killtracker-0.17.0 → aa_killtracker-1.0.0a1}/killtracker/apps.py

@@ -9,7 +9,5 @@ class KillmailsConfig(AppConfig):
     verbose_name = f"Killtracker v{__version__}"
 
     def ready(self) -> None:
-        from . import checks  # noqa: F401 pylint: disable=unused-import
-        from .core.killmails import Killmail
-
-        Killmail.reset_lock_key()
+        import killtracker.checks  # noqa: F401 pylint: disable=unused-import
+        import killtracker.signals  # noqa: F401 pylint: disable=unused-import

aa_killtracker-1.0.0a1/killtracker/core/discord.py

@@ -0,0 +1,162 @@
+"""Send messages to Discord webhooks."""
+
+import datetime as dt
+import json
+from copy import copy
+from dataclasses import dataclass
+from http import HTTPStatus
+from time import sleep
+from typing import List, Optional
+
+import dhooks_lite
+
+from django.core.cache import cache
+from django.utils.timezone import now
+
+from allianceauth.services.hooks import get_extension_logger
+from app_utils.json import JSONDateTimeDecoder, JSONDateTimeEncoder
+from app_utils.logging import LoggerAddTag
+
+from killtracker import APP_NAME, HOMEPAGE_URL, __title__, __version__
+from killtracker.app_settings import KILLTRACKER_DISCORD_SEND_DELAY
+from killtracker.core.helpers import datetime_or_none
+
+_DEFAULT_429_TIMEOUT = 600
+
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
+
+class HTTPError(Exception):
+    """A HTTP error."""
+
+    def __init__(self, status_code: int):
+        self.status_code = status_code
+
+
+class WebhookRateLimitExhausted(Exception):
+    """The rate limit of a webhook has been exhausted."""
+
+    def __init__(self, retry_at: dt.datetime, is_original: bool = True):
+        self.retry_at = retry_at
+        self.is_original = is_original
+
+
+@dataclass
+class DiscordMessage:
+    """A Discord message created from a Killmail."""
+
+    avatar_url: Optional[str] = None
+    content: Optional[str] = None
+    embeds: Optional[List[dhooks_lite.Embed]] = None
+    killmail_id: int = 0  # Killmail ID this message from created from
+    username: Optional[str] = None
+
+    def __post_init__(self):
+        if not self.content and not self.embeds:
+            raise ValueError("Message must have content or embeds to be valid")
+
+    def to_json(self) -> str:
+        """Converts a Discord message into a JSON object and returns it."""
+
+        if self.embeds:
+            embeds_list = [obj.asdict() for obj in self.embeds]
+        else:
+            embeds_list = None
+
+        message = {}
+        if self.killmail_id:
+            message["killmail_id"] = self.killmail_id
+        if self.content:
+            message["content"] = self.content
+        if embeds_list:
+            message["embeds"] = embeds_list
+        if self.username:
+            message["username"] = self.username
+        if self.avatar_url:
+            message["avatar_url"] = self.avatar_url
+
+        return json.dumps(message, cls=JSONDateTimeEncoder)
+
+    @classmethod
+    def from_json(cls, s: str) -> "DiscordMessage":
+        """Creates a DiscordMessage object from an JSON object and returns it."""
+        message1: dict = json.loads(s, cls=JSONDateTimeDecoder)
+        message2 = copy(message1)
+        if message1.get("embeds"):
+            message2["embeds"] = [
+                dhooks_lite.Embed.from_dict(embed_dict)
+                for embed_dict in message1.get("embeds")
+            ]
+        else:
+            message2["embeds"] = None
+        return cls(**message2)
+
+
+def send_message_to_webhook(name: str, url: str, message: DiscordMessage) -> int:
+    """Send a message to a Discord webhook and returns the ID of new message."""
+
+    key_retry_at = _make_key_retry_at(url)
+    retry_at = datetime_or_none(cache.get(key_retry_at))
+    if retry_at is not None and retry_at > now():
+        raise WebhookRateLimitExhausted(retry_at=retry_at, is_original=False)
+
+    key_last_request = _make_key_last_request(url)
+    last_request = datetime_or_none(cache.get(key_last_request))
+    if last_request is not None:
+        next_slot = last_request + dt.timedelta(seconds=KILLTRACKER_DISCORD_SEND_DELAY)
+        seconds = (next_slot - now()).total_seconds()
+        if seconds > 0:
+            logger.debug(
+                "%s: Waiting %f seconds for next free slot for webhook", name, seconds
+            )
+            sleep(seconds)
+
+    hook = dhooks_lite.Webhook(
+        url=url,
+        user_agent=dhooks_lite.UserAgent(
+            name=APP_NAME, url=HOMEPAGE_URL, version=__version__
+        ),
+    )
+    response = hook.execute(
+        content=message.content,
+        embeds=message.embeds,
+        username=message.username,
+        avatar_url=message.avatar_url,
+        wait_for_response=True,
+        max_retries=0,  # we will handle retries ourselves
+    )
+    cache.set(key_last_request, now(), timeout=KILLTRACKER_DISCORD_SEND_DELAY + 30)
+    logger.debug(
+        "%s: Response from Discord for creating message from killmail %d: %s %s %s",
+        name,
+        message.killmail_id,
+        response.status_code,
+        response.headers,
+        response.content,
+    )
+    if not response.status_ok:
+        if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+            try:
+                retry_after = int(response.headers["Retry-After"])
+            except KeyError:
+                retry_after = _DEFAULT_429_TIMEOUT
+            retry_at = now() + dt.timedelta(seconds=retry_after)
+            cache.set(key_retry_at, retry_at, timeout=retry_after + 60)
+            raise WebhookRateLimitExhausted(retry_at=retry_at, is_original=True)
+
+        raise HTTPError(response.status_code)
+
+    try:
+        message_id = int(response.content.get("id"))
+    except (AttributeError, ValueError):
+        message_id = 0
+
+    return message_id
+
+
+def _make_key_last_request(url):
+    return f"killtracker-webhook-last-request-{url}"
+
+
+def _make_key_retry_at(url):
+    return f"killtracker-webhook-retry-at-{url}"

aa_killtracker-1.0.0a1/killtracker/core/helpers.py

@@ -0,0 +1,13 @@
+"""Helper functions for core modules."""
+
+import datetime as dt
+from typing import Any, Optional
+
+
+def datetime_or_none(v: Any) -> Optional[dt.datetime]:
+    """Returns as datetime when it is a datetime else returns None."""
+    if v is None:
+        return None
+    if not isinstance(v, dt.datetime):
+        return None
+    return v

aa_killtracker-0.17.0/killtracker/core/discord_messages.py → aa_killtracker-1.0.0a1/killtracker/core/trackers.py

@@ -1,9 +1,12 @@
-"""Create discord messages from killmails."""
+"""Generate Discord messages from tracked killmails."""
 
-from typing import NamedTuple, Optional
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
 
 import dhooks_lite
-from requests.exceptions import HTTPError
+import requests
 
 from eveuniverse.helpers import EveEntityNameResolver
 from eveuniverse.models import EveEntity, EveSolarSystem
@@ -16,33 +19,54 @@ from app_utils.urls import static_file_absolute_url
 from app_utils.views import humanize_value
 
 from killtracker import __title__
-from killtracker.models import Tracker
-
-from .killmails import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
+from killtracker.core.discord import DiscordMessage
+from killtracker.core.zkb import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
 
-ICON_SIZE = 128
+if TYPE_CHECKING:
+    from killtracker.models import Tracker
 
+_ICON_SIZE = 128
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
 
-class MainOrgInfo(NamedTuple):
+def create_discord_message_from_killmail(
+    tracker: Tracker, killmail: Killmail, intro_text: Optional[str] = None
+) -> "DiscordMessage":
+    """Creates a Discord message from a Killmail and returns it."""
+    m = DiscordMessage(
+        killmail_id=killmail.id,
+        content=_create_content(tracker, intro_text),
+        embeds=[_create_embed(tracker, killmail)],
+    )
+    return m
+
+
+@dataclass(frozen=True)
+class _MainOrgInfo:
     """Infos about a main organization."""
 
-    text: str = ""
+    icon_url: str = ""
     name: str = ""
-    icon_url: str = eveimageserver.alliance_logo_url(1, size=ICON_SIZE)
     show_as_fleet_kill: bool = False
+    text: str = ""
+
+    def __post_init__(self):
+        if self.icon_url == "":
+            icon_url = eveimageserver.alliance_logo_url(1, size=_ICON_SIZE)
+            object.__setattr__(self, "icon_url", icon_url)
 
 
-class FinalAttackerInfo(NamedTuple):
+@dataclass(frozen=True)
+class _FinalAttackerInfo:
     """Infos about the final attacker on a killmail."""
 
     name: str = ""
     ship_type: str = ""
 
 
-class VictimInfo(NamedTuple):
+@dataclass(frozen=True)
+class _VictimInfo:
     """Infos about the victim of a killmail."""
 
     name: str
@@ -53,9 +77,11 @@ class VictimInfo(NamedTuple):
     ship_type_icon_url: str
 
 
-def create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
+def _create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
     """Create content for Discord message for a killmail."""
 
+    from killtracker.models import Tracker
+
     intro_parts = []
 
     if tracker.ping_type == Tracker.ChannelPingType.EVERYBODY:
@@ -69,7 +95,7 @@ def create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
             for group in tracker.ping_groups.all():
                 try:
                     role = DiscordUser.objects.group_to_role(group)  # type: ignore
-                except HTTPError:
+                except requests.exceptions.HTTPError:
                     logger.warning(
                         "Failed to get Discord roles. Can not ping groups.",
                         exc_info=True,
@@ -102,7 +128,7 @@ def _import_discord_user():
     return DiscordUser
 
 
-def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
+def _create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
     """Create Discord embed for a killmail."""
 
     resolver: EveEntityNameResolver = EveEntity.objects.bulk_resolve_names(  # type: ignore
@@ -111,7 +137,7 @@ def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
 
     # self info
     distance_text = ""
-    main_org = MainOrgInfo()
+    main_org = _MainOrgInfo()
     main_ship_group_text = ""
     tracked_ship_types_text = ""
 
@@ -137,10 +163,24 @@ def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
     title = _calc_title(killmail, resolver, main_org, victim)
     thumbnail_url = _calc_thumbnail_url(victim, main_org)
 
-    return _create_embed(killmail, tracker, victim, description, title, thumbnail_url)
+    author = _calc_author(victim)
+    zkb_icon_url = static_file_absolute_url("killtracker/zkb_icon.png")
+    embed_color = int(tracker.color[1:], 16) if tracker and tracker.color else None
+
+    embed = dhooks_lite.Embed(
+        author=author,
+        description=description,
+        title=title,
+        url=f"{ZKB_KILLMAIL_BASEURL}{killmail.id}/",
+        thumbnail=dhooks_lite.Thumbnail(url=thumbnail_url),
+        footer=dhooks_lite.Footer(text="zKillboard", icon_url=zkb_icon_url),
+        timestamp=killmail.time,
+        color=embed_color,
+    )
+    return embed
 
 
-def _calc_author(victim: VictimInfo):
+def _calc_author(victim: _VictimInfo):
     # TODO This is a workaround for Embed.Author.name. Address in dhooks_lite
     return (
         dhooks_lite.Author(
@@ -158,10 +198,10 @@ def _calc_description(
     killmail: Killmail,
     resolver: EveEntityNameResolver,
     distance_text: str,
-    main_org: MainOrgInfo,
+    main_org: _MainOrgInfo,
     main_ship_group_text: str,
     tracked_ship_types_text: str,
-    victim: VictimInfo,
+    victim: _VictimInfo,
 ):
     solar_system_text = _calc_solar_system(tracker, killmail)
     total_value = (
@@ -186,18 +226,18 @@ def _calc_description(
 
 def _calc_victim(
     tracker: Tracker, killmail: Killmail, resolver: EveEntityNameResolver
-) -> VictimInfo:
+) -> _VictimInfo:
     if killmail.victim.alliance_id:
         victim_organization = resolver.to_name(killmail.victim.alliance_id)
         victim_org_url = zkillboard.alliance_url(killmail.victim.alliance_id)
         victim_org_icon_url = eveimageserver.alliance_logo_url(
-            killmail.victim.alliance_id, size=ICON_SIZE
+            killmail.victim.alliance_id, size=_ICON_SIZE
         )
     elif killmail.victim.corporation_id:
         victim_organization = resolver.to_name(killmail.victim.corporation_id)
         victim_org_url = zkillboard.corporation_url(killmail.victim.corporation_id)
         victim_org_icon_url = eveimageserver.corporation_logo_url(
-            killmail.victim.corporation_id, size=ICON_SIZE
+            killmail.victim.corporation_id, size=_ICON_SIZE
         )
     else:
         victim_organization = ""
@@ -229,12 +269,12 @@ def _calc_victim(
     ship_type = resolver.to_name(ship_type_id) if ship_type_id else ""
 
     ship_type_icon_url = (
-        eveimageserver.type_icon_url(ship_type_id, size=ICON_SIZE)
+        eveimageserver.type_icon_url(ship_type_id, size=_ICON_SIZE)
         if ship_type_id
         else ""
     )
 
-    return VictimInfo(
+    return _VictimInfo(
         organization=victim_organization,
         org_url=victim_org_url,
         org_icon_url=victim_org_icon_url,
@@ -246,7 +286,7 @@ def _calc_victim(
 
 def _calc_final_attacker(
     tracker: Tracker, killmail: Killmail, resolver: EveEntityNameResolver
-) -> FinalAttackerInfo:
+) -> _FinalAttackerInfo:
     for attacker in killmail.attackers:
         if attacker.is_final_blow:
             final_attacker = attacker
@@ -255,7 +295,7 @@ def _calc_final_attacker(
         final_attacker = None
 
     if not final_attacker:
-        return FinalAttackerInfo()
+        return _FinalAttackerInfo()
 
     if final_attacker.corporation_id:
         final_attacker_corporation_zkb_link = _corporation_zkb_link(
@@ -286,7 +326,7 @@ def _calc_final_attacker(
 
     ship_type = resolver.to_name(ship_type_id) if ship_type_id else ""
 
-    return FinalAttackerInfo(name=final_attacker_str, ship_type=ship_type)
+    return _FinalAttackerInfo(name=final_attacker_str, ship_type=ship_type)
 
 
 def _calc_solar_system(tracker: Tracker, killmail: Killmail):
@@ -338,12 +378,12 @@ def _calc_main_group(
         if main_org_entity.is_corporation:
             main_org_link = _corporation_zkb_link(tracker, main_org_entity.id, resolver)
             main_org_icon_url = eveimageserver.corporation_logo_url(
-                main_org_entity.id, size=ICON_SIZE
+                main_org_entity.id, size=_ICON_SIZE
             )
         else:
             main_org_link = _alliance_zkb_link(tracker, main_org_entity.id, resolver)
             main_org_icon_url = eveimageserver.alliance_logo_url(
-                main_org_entity.id, size=ICON_SIZE
+                main_org_entity.id, size=_ICON_SIZE
             )
         main_org_text = f" | Main group: {main_org_link} ({main_org_entity.count})"
         show_as_fleet_kill = tracker.identify_fleets
@@ -351,7 +391,7 @@ def _calc_main_group(
         show_as_fleet_kill = False
         main_org_text = main_org_name = main_org_icon_url = ""
 
-    return MainOrgInfo(
+    return _MainOrgInfo(
         text=main_org_text,
         name=main_org_name,
         icon_url=main_org_icon_url,
@@ -380,7 +420,7 @@ def _calc_tracked_ship_types(
     return f"\nTracked ship types involved: **{ship_types_text}**"
 
 
-def _calc_thumbnail_url(victim: VictimInfo, main_org: MainOrgInfo):
+def _calc_thumbnail_url(victim: _VictimInfo, main_org: _MainOrgInfo):
     if main_org.show_as_fleet_kill:
         return main_org.icon_url
 
@@ -390,8 +430,8 @@ def _calc_thumbnail_url(victim: VictimInfo, main_org: MainOrgInfo):
 def _calc_title(
     killmail: Killmail,
     resolver: EveEntityNameResolver,
-    main_org: MainOrgInfo,
-    victim: VictimInfo,
+    main_org: _MainOrgInfo,
+    victim: _VictimInfo,
 ):
     solar_system_name = (
         resolver.to_name(killmail.solar_system_id) if killmail.solar_system_id else ""
@@ -403,31 +443,6 @@ def _calc_title(
     return f"{solar_system_name} | {victim.ship_type} | Killmail"
 
 
-def _create_embed(
-    killmail: Killmail,
-    tracker: Tracker,
-    victim: VictimInfo,
-    description: str,
-    title: str,
-    thumbnail_url: str,
-):
-    author = _calc_author(victim)
-    zkb_icon_url = static_file_absolute_url("killtracker/zkb_icon.png")
-    embed_color = int(tracker.color[1:], 16) if tracker and tracker.color else None
-
-    embed = dhooks_lite.Embed(
-        author=author,
-        description=description,
-        title=title,
-        url=f"{ZKB_KILLMAIL_BASEURL}{killmail.id}/",
-        thumbnail=dhooks_lite.Thumbnail(url=thumbnail_url),
-        footer=dhooks_lite.Footer(text="zKillboard", icon_url=zkb_icon_url),
-        timestamp=killmail.time,
-        color=embed_color,
-    )
-    return embed
-
-
 def _character_zkb_link(
     tracker: Tracker, entity_id: int, resolver: EveEntityNameResolver
 ) -> str:

aa_killtracker-1.0.0a1/killtracker/core/workers.py

@@ -0,0 +1,46 @@
+"""Allows tasks to find out whether their worker is currently shutting down.
+
+This enables long running tasks to abort early,
+which helps to speed up a warm worker shutdown.
+"""
+
+from celery import Task
+
+from django.core.cache import cache
+
+from allianceauth.services.hooks import get_extension_logger
+from app_utils.logging import LoggerAddTag
+
+from killtracker import __title__
+
+_TIMEOUT_SECONDS = 120
+
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
+
+def state_reset(hostname: str) -> None:
+    """Resets the shutting down state for a worker."""
+    cache.delete(_make_key(hostname))
+
+
+def state_set(hostname: str) -> None:
+    """Sets a worker into the shutting down state."""
+    cache.set(_make_key(hostname), "shutting down", timeout=_TIMEOUT_SECONDS)
+
+
+def is_shutting_down(task: Task) -> bool:
+    """Reports whether the worker of a celery task is currently shutting down."""
+    try:
+        hostname = str(task.request.hostname)
+    except (AttributeError, TypeError, ValueError):
+        logger.warning("Failed to retrieve hostname: %s", task)
+        return False
+
+    if cache.get(_make_key(hostname)) is None:
+        return False
+
+    return True
+
+
+def _make_key(hostname: str) -> str:
+    return f"killtracker-worker-shutting-down-{hostname}"