File size: 5,231 Bytes
71687cf | 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 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | # Copyright (C) 2012 Anaconda, Inc
# SPDX-License-Identifier: BSD-3-Clause
"""
Handles all caching logic including:
- Retrieving from cache
- Saving to cache
- Determining whether not certain items have expired and need to be refreshed
"""
from __future__ import annotations
import logging
import os
from datetime import datetime, timezone
from functools import wraps
from pathlib import Path
from typing import TYPE_CHECKING
from platformdirs import user_cache_dir
from ..base.constants import (
APP_NAME,
NOTICES_CACHE_FN,
NOTICES_CACHE_SUBDIR,
NOTICES_DECORATOR_DISPLAY_INTERVAL,
)
from ..common.serialize import json
from ..utils import ensure_dir_exists
from .types import ChannelNoticeResponse
if TYPE_CHECKING:
from collections.abc import Sequence
from .types import ChannelNotice
logger = logging.getLogger(__name__)
def cached_response(func):
@wraps(func)
def wrapper(url: str, name: str):
cache_dir = get_notices_cache_dir()
cache_val = get_notice_response_from_cache(url, name, cache_dir)
if cache_val:
return cache_val
return_value = func(url, name)
if return_value is not None:
write_notice_response_to_cache(return_value, cache_dir)
return return_value
return wrapper
def is_notice_response_cache_expired(
channel_notice_response: ChannelNoticeResponse,
) -> bool:
"""
This checks the contents of the cache response to see if it is expired.
If for whatever reason we encounter an exception while parsing the individual
messages, we assume an invalid cache and return true.
"""
now = datetime.now(timezone.utc)
def is_channel_notice_expired(expired_at: datetime | None) -> bool:
"""If there is no "expired_at" field present assume it is expired."""
if expired_at is None:
return True
return expired_at < now
return any(
is_channel_notice_expired(chn.expired_at)
for chn in channel_notice_response.notices
)
@ensure_dir_exists
def get_notices_cache_dir() -> Path:
"""Returns the location of the notices cache directory as a Path object"""
cache_dir = user_cache_dir(APP_NAME, appauthor=APP_NAME)
return Path(cache_dir).joinpath(NOTICES_CACHE_SUBDIR)
def get_notices_cache_file() -> Path:
"""
Return path of notices cache
If the file does not exist, we create it with natural filesystem timestamps,
then set only the modification time to be in the past. This ensures notices
are checked and displayed immediately rather than waiting for the full
display interval.
"""
cache_dir = get_notices_cache_dir()
cache_file = cache_dir.joinpath(NOTICES_CACHE_FN)
if not cache_file.is_file():
with open(cache_file, "w") as fp:
fp.write("")
# Keep natural access time, set only mtime to past for immediate notice display
stat = cache_file.stat()
past_mtime = stat.st_mtime - NOTICES_DECORATOR_DISPLAY_INTERVAL
os.utime(cache_file, (stat.st_atime, past_mtime))
return cache_file
def get_notice_response_from_cache(
url: str, name: str, cache_dir: Path
) -> ChannelNoticeResponse | None:
"""Retrieves a notice response object from cache if it exists."""
cache_key = ChannelNoticeResponse.get_cache_key(url, cache_dir)
if os.path.isfile(cache_key):
with open(cache_key) as fp:
data = json.load(fp)
chn_ntc_resp = ChannelNoticeResponse(url, name, data)
if not is_notice_response_cache_expired(chn_ntc_resp):
return chn_ntc_resp
def write_notice_response_to_cache(
channel_notice_response: ChannelNoticeResponse, cache_dir: Path
) -> None:
"""Writes our notice data to our local cache location."""
cache_key = ChannelNoticeResponse.get_cache_key(
channel_notice_response.url, cache_dir
)
with open(cache_key, "w") as fp:
json.dump(channel_notice_response.json_data, fp)
def mark_channel_notices_as_viewed(
cache_file: Path, channel_notices: Sequence[ChannelNotice]
) -> None:
"""Insert channel notice into our database marking it as read."""
notice_ids = {chn.id for chn in channel_notices}
with open(cache_file) as fp:
contents: str = fp.read()
contents_unique = set(filter(None, set(contents.splitlines())))
contents_new = contents_unique.union(notice_ids)
# Save new version of cache file
with open(cache_file, "w") as fp:
fp.write("\n".join(contents_new))
def get_viewed_channel_notice_ids(
cache_file: Path, channel_notices: Sequence[ChannelNotice]
) -> set[str]:
"""Return the ids of the channel notices which have already been seen."""
notice_ids = {chn.id for chn in channel_notices}
with open(cache_file) as fp:
contents: str = fp.read()
contents_unique = set(filter(None, set(contents.splitlines())))
return notice_ids.intersection(contents_unique)
def clear_cache() -> None:
"""
Removes all files in notices cache
"""
cache_dir = Path(get_notices_cache_dir())
for cache_file in cache_dir.iterdir():
if cache_file.is_file():
cache_file.unlink()
|