feat(archive-cache): implement more usage stats for later easier evictions

rhodecode/lib/rc_cache/archive_cache/fanout_cache.py

@@ -1,264 +1,278 b''
 # Copyright (C) 2015-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import codecs
 import contextlib
 import functools
 import os
 import logging
 import time
 import typing
 import zlib
 
 from rhodecode.lib.ext_json import json
 from .lock import GenerationLock
 
 log = logging.getLogger(__name__)
 
 cache_meta = None
 
 UNKNOWN = -241
 NO_VAL = -917
 
 MODE_BINARY = 'BINARY'
 
 
 class FileSystemCache:
 
     def __init__(self, index, directory, **settings):
         self._index = index
         self._directory = directory
 
     def _write_file(self, full_path, iterator, mode, encoding=None):
         full_dir, _ = os.path.split(full_path)
 
         for count in range(1, 11):
             with contextlib.suppress(OSError):
                 os.makedirs(full_dir)
 
             try:
                 # Another cache may have deleted the directory before
                 # the file could be opened.
                 writer = open(full_path, mode, encoding=encoding)
             except OSError:
                 if count == 10:
                     # Give up after 10 tries to open the file.
                     raise
                 continue
 
             with writer:
                 size = 0
                 for chunk in iterator:
                     size += len(chunk)
                     writer.write(chunk)
                 return size
 
     def _get_keyfile(self, key):
         return os.path.join(self._directory, f'{key}.key')
 
     def store(self, key, value_reader, metadata):
         filename, full_path = self.random_filename()
         key_file = self._get_keyfile(key)
 
         # STORE METADATA
         _metadata = {
             "version": "v1",
-            "timestamp": time.time(),
             "filename": filename,
             "full_path": full_path,
             "key_file": key_file,
+            "store_time": time.time(),
+            "access_count": 1,
+            "access_time": 0,
+            "size": 0
         }
         if metadata:
             _metadata.update(metadata)
 
         reader = functools.partial(value_reader.read, 2**22)
 
         iterator = iter(reader, b'')
         size = self._write_file(full_path, iterator, 'xb')
+        metadata['size'] = size
 
         # after archive is finished, we create a key to save the presence of the binary file
         with open(key_file, 'wb') as f:
             f.write(json.dumps(_metadata))
 
         return key, size, MODE_BINARY, filename, _metadata
 
     def fetch(self, key) -> tuple[typing.BinaryIO, dict]:
         if key not in self:
             raise KeyError(key)
 
         key_file = self._get_keyfile(key)
         with open(key_file, 'rb') as f:
             metadata = json.loads(f.read())
 
         filename = metadata['filename']
 
-        return open(os.path.join(self._directory, filename), 'rb'), metadata
+        try:
+            return open(os.path.join(self._directory, filename), 'rb'), metadata
+        finally:
+            # update usage stats, count and accessed
+            metadata["access_count"] = metadata.get("access_count", 0) + 1
+            metadata["access_time"] = time.time()
+
+            with open(key_file, 'wb') as f:
+                f.write(json.dumps(metadata))
 
     def random_filename(self):
         """Return filename and full-path tuple for file storage.
 
         Filename will be a randomly generated 28 character hexadecimal string
         with ".archive_cache" suffixed. Two levels of sub-directories will be used to
         reduce the size of directories. On older filesystems, lookups in
         directories with many files may be slow.
         """
 
         hex_name = codecs.encode(os.urandom(16), 'hex').decode('utf-8')
         sub_dir = os.path.join(hex_name[:2], hex_name[2:4])
         name = hex_name[4:] + '.archive_cache'
         filename = os.path.join(sub_dir, name)
         full_path = os.path.join(self._directory, filename)
         return filename, full_path
 
     def hash(self, key):
         """Compute portable hash for `key`.
 
         :param key: key to hash
         :return: hash value
 
         """
         mask = 0xFFFFFFFF
         return zlib.adler32(key.encode('utf-8')) & mask  # noqa
 
     def __contains__(self, key):
         """Return `True` if `key` matching item is found in cache.
 
         :param key: key matching item
         :return: True if key matching item
 
         """
         key_file = self._get_keyfile(key)
         return os.path.exists(key_file)
 
 
 class FanoutCache:
     """Cache that shards keys and values."""
 
     def __init__(
         self, directory=None, **settings
     ):
         """Initialize cache instance.
 
         :param str directory: cache directory
         :param settings: settings dict
 
         """
         if directory is None:
             raise ValueError('directory cannot be None')
 
         directory = str(directory)
         directory = os.path.expanduser(directory)
         directory = os.path.expandvars(directory)
         self._directory = directory
 
         self._count = settings.pop('cache_shards')
         self._locking_url = settings.pop('locking_url')
 
+        self._eviction_policy = settings['cache_eviction_policy']
+        self._cache_size_limit = settings['cache_size_limit']
+
         self._shards = tuple(
             FileSystemCache(
                 index=num,
                 directory=os.path.join(directory, 'shard_%03d' % num),
                 **settings,
             )
             for num in range(self._count)
         )
         self._hash = self._shards[0].hash
 
     def get_lock(self, lock_key):
         return GenerationLock(lock_key, self._locking_url)
 
     def _get_shard(self, key) -> FileSystemCache:
         index = self._hash(key) % self._count
         shard = self._shards[index]
         return shard
 
     def store(self, key, value_reader, metadata=None):
         shard = self._get_shard(key)
         return shard.store(key, value_reader, metadata)
 
     def fetch(self, key):
         """Return file handle corresponding to `key` from cache.
         """
         shard = self._get_shard(key)
         return shard.fetch(key)
 
     def has_key(self, key):
         """Return `True` if `key` matching item is found in cache.
 
         :param key: key for item
         :return: True if key is found
 
         """
         shard = self._get_shard(key)
         return key in shard
 
     def __contains__(self, item):
         return self.has_key(item)
 
     def evict(self):
         """Remove old items based on the conditions"""
         # TODO: Implement this...
         return
 
 
 def get_archival_config(config):
 
     final_config = {
 
     }
 
     for k, v in config.items():
         if k.startswith('archive_cache'):
             final_config[k] = v
 
     return final_config
 
 
 def get_archival_cache_store(config):
 
     global cache_meta
     if cache_meta is not None:
         return cache_meta
 
     config = get_archival_config(config)
     backend = config['archive_cache.backend.type']
     if backend != 'filesystem':
         raise ValueError('archive_cache.backend.type only supports "filesystem"')
 
     archive_cache_locking_url = config['archive_cache.locking.url']
     archive_cache_dir = config['archive_cache.filesystem.store_dir']
     archive_cache_size_gb = config['archive_cache.filesystem.cache_size_gb']
     archive_cache_shards = config['archive_cache.filesystem.cache_shards']
     archive_cache_eviction_policy = config['archive_cache.filesystem.eviction_policy']
 
     log.debug('Initializing archival cache instance under %s', archive_cache_dir)
 
     # check if it's ok to write, and re-create the archive cache
     if not os.path.isdir(archive_cache_dir):
         os.makedirs(archive_cache_dir, exist_ok=True)
 
     d_cache = FanoutCache(
         archive_cache_dir,
         locking_url=archive_cache_locking_url,
         cache_shards=archive_cache_shards,
         cache_size_limit=archive_cache_size_gb * 1024 * 1024 * 1024,
         cache_eviction_policy=archive_cache_eviction_policy
     )
     cache_meta = d_cache
     return cache_meta
-

rhodecode/lib/rc_cache/archive_cache/utils.py

@@ -1,71 +1,72 b''
 # Copyright (C) 2015-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
+
 import os
 
 
 class ArchiveCacheLock(Exception):
     pass
 
 
 def archive_iterator(_reader, block_size: int = 4096 * 512):
     # 4096 * 64 = 64KB
     while 1:
         data = _reader.read(block_size)
         if not data:
             break
         yield data
 
 
 def get_directory_statistics(start_path):
     """
     total_files, total_size, directory_stats = get_directory_statistics(start_path)
 
     print(f"Directory statistics for: {start_path}\n")
     print(f"Total files: {total_files}")
     print(f"Total size: {format_size(total_size)}\n")
 
     :param start_path:
     :return:
     """
 
     total_files = 0
     total_size = 0
     directory_stats = {}
 
     for dir_path, dir_names, file_names in os.walk(start_path):
         dir_size = 0
         file_count = len(file_names)
 
         for file in file_names:
             filepath = os.path.join(dir_path, file)
             file_size = os.path.getsize(filepath)
             dir_size += file_size
 
         directory_stats[dir_path] = {'file_count': file_count, 'size': dir_size}
         total_files += file_count
         total_size += dir_size
 
     return total_files, total_size, directory_stats
 
 
 def format_size(size):
     # Convert size in bytes to a human-readable format (e.g., KB, MB, GB)
     for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
         if size < 1024:
             return f"{size:.2f} {unit}"
         size /= 1024