pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/cli/start.py

@@ -0,0 +1,56 @@
+import logging
+import platform
+import sys
+
+import click
+
+from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.typing_utils import Optional
+
+
+@click.command(help='Start a local compute node', hidden=True)
+@click.option('--host', default='127.0.0.1', required=False)  # TODO: Validate host
+@click.option('--port', default=5000, type=click.IntRange(1, 65_535), required=False)
+@click.option('--tls-certificate', type=click.Path(exists=True), required=False, hidden=True)
+@click.option('--tls-key', type=click.Path(exists=True), required=False, hidden=True)
+@click.option('--initialize-network-buffer', is_flag=True, help='Initialize the remote host network buffer and exit')
+def start(
+    host: str, port: int, tls_certificate: Optional[str], tls_key: Optional[str], initialize_network_buffer: bool
+) -> None:
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    if platform.system() == 'Windows':
+        raise Exception('Starting a compute node is currently not supported on Windows')
+
+    if tls_certificate and not tls_key or tls_key and not tls_certificate:
+        raise Exception('Options --tls-certificate and --tls-key must be specified together')
+
+    if initialize_network_buffer:
+        from biolib.compute_node.job_worker.network_buffer import (  # pylint: disable=import-outside-toplevel
+            NetworkBuffer,
+        )
+
+        network_buffer = NetworkBuffer.get_instance()
+        created = network_buffer.fill_buffer()
+        logger_no_user_data.info(f'Initialized network buffer (created {created} networks)')
+        return
+
+    try:
+        from biolib.compute_node.webserver import webserver  # pylint: disable=import-outside-toplevel
+
+        webserver.start_webserver(
+            host=host,
+            port=port,
+            tls_pem_key_path=tls_key,
+            tls_pem_certificate_path=tls_certificate,
+        )
+    except ModuleNotFoundError as error:
+        if error.name in ('flask', 'gunicorn'):
+            print(
+                'To use this command, please install the compute-node extras with '
+                '"pip3 install --upgrade pybiolib[compute-node]"',
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        raise error

biolib/compute_node/cloud_utils/cloud_utils.py

@@ -1,187 +1,138 @@
 # pylint: disable=unsubscriptable-object
-
+import base64
+import json
 import os
 import subprocess
 import time
-import signal
-from multiprocessing import Process
 from datetime import datetime
 from socket import gethostbyname, gethostname
-import requests
 
-from biolib import utils
-from biolib.biolib_errors import BioLibError
-from biolib.biolib_logging import logger
-from biolib.typing_utils import Optional
+from biolib import api, utils
 from biolib.biolib_api_client import BiolibApiClient
-from biolib.compute_node.cloud_utils.enclave_parent_types import VsockProxyResponse
-from biolib.compute_node.webserver.webserver_types import WebserverConfig, ComputeNodeInfo, ShutdownTimes
-from biolib.biolib_api_client import RemoteHost
-
+from biolib.biolib_logging import logger_no_user_data
+from biolib.compute_node.webserver.webserver_types import ComputeNodeInfo, ShutdownTimes, WebserverConfig
+from biolib.typing_utils import Dict, List, Optional, cast
 
-class CloudAutoShutdownTimer(Process):
-    def __init__(self, seconds_to_wait: int) -> None:
-        super().__init__()
-        self._seconds_to_wait = seconds_to_wait
 
-    def run(self) -> None:
-        time.sleep(self._seconds_to_wait)
-        CloudUtils.deregister_and_shutdown()
+def trust_ceritificates(certs_data: List[str]) -> None:
+    ca_directory_amazon_linux_2 = '/etc/pki/ca-trust/source/anchors/'
 
+    if not os.path.exists(ca_directory_amazon_linux_2):
+        logger_no_user_data.error(f'Certificate path not found at {ca_directory_amazon_linux_2}')
+        return
 
-class _EnclaveUtils:
-    _BASE_URL = 'http://127.0.0.1:5005'
-
-    @staticmethod
-    def get_webserver_config():
-        response = requests.get(f'{_EnclaveUtils._BASE_URL}/config/', timeout=5)
-        return response.json()
-
-    @staticmethod
-    def deregister_and_shutdown() -> None:
-        requests.post(url=f'{_EnclaveUtils._BASE_URL}/deregister_and_shutdown/', timeout=5)
+    for idx, cert_data in enumerate(certs_data):
+        with open(f'{ca_directory_amazon_linux_2}bl-cert-{idx}.crt', mode='w') as cert_file:
+            cert_file.write(cert_data)
 
-    @staticmethod
-    def start_vsock_proxy(remote_host: RemoteHost) -> VsockProxyResponse:
-        response = requests.post(url=f'{_EnclaveUtils._BASE_URL}/vsock_proxy/', json=remote_host, timeout=5)
-        vsock_proxy: VsockProxyResponse = response.json()
-        return vsock_proxy
-
-    @staticmethod
-    def stop_vsock_proxy(vsock_proxy_id: str) -> None:
-        requests.delete(url=f'{_EnclaveUtils._BASE_URL}/vsock_proxy/{vsock_proxy_id}/', timeout=5)
-
-    @staticmethod
-    def log_message_to_log_file(log_message: str, level: int) -> None:
-        requests.post(
-            url=f'{_EnclaveUtils._BASE_URL}/log/',
-            json={
-                'log_message': log_message,
-                'level': level
-            },
-            timeout=5,
-        )
+    result = subprocess.run(['update-ca-trust'], capture_output=True, check=False)
+    logger_no_user_data.debug(result.stdout.decode())
+    if result.returncode == 0:
+        logger_no_user_data.info('Certificates added successfully!')
+    else:
+        logger_no_user_data.error(f'Failed to update certificates: {result.stderr.decode()}')
 
 
 class CloudUtils:
     _webserver_config: Optional[WebserverConfig] = None
-    enclave = _EnclaveUtils
-    _auto_shutdown_timer_pid_file_name: str = '/tmp/biolib_auto_shutdown_timer.pid'
 
     @staticmethod
     def initialize() -> None:
-        logger.debug('Reporting availability...')
+        logger_no_user_data.info('Reporting availability...')
         CloudUtils._report_availability()
-        CloudUtils.start_auto_shutdown_timer()
 
     @staticmethod
     def get_webserver_config() -> WebserverConfig:
         if CloudUtils._webserver_config:
             return CloudUtils._webserver_config
 
-        if utils.BIOLIB_IS_RUNNING_IN_ENCLAVE:
-            CloudUtils._webserver_config = CloudUtils.enclave.get_webserver_config()
-
-        else:
-            CloudUtils._webserver_config = WebserverConfig(
-                compute_node_info=ComputeNodeInfo(
-                   auth_token=CloudUtils._get_environment_variable('BIOLIB_COMPUTE_NODE_AUTH_TOKEN'),
-                   public_id=CloudUtils._get_environment_variable('BIOLIB_COMPUTE_NODE_PUBLIC_ID'),
-                   ip_address=gethostbyname(gethostname())
-                ),
-                base_url=CloudUtils._get_environment_variable('BIOLIB_BASE_URL'),
-                ecr_region_name=CloudUtils._get_environment_variable('BIOLIB_ECR_REGION_NAME'),
-                s3_general_storage_bucket_name=CloudUtils._get_environment_variable(
-                    'BIOLIB_S3_GENERAL_STORAGE_BUCKET_NAME'
+        CloudUtils._webserver_config = WebserverConfig(
+            compute_node_info=ComputeNodeInfo(
+                auth_token=CloudUtils._get_environment_variable_or_fail('BIOLIB_COMPUTE_NODE_AUTH_TOKEN'),
+                ip_address=os.environ.get('BIOLIB_COMPUTE_NODE_CUSTOM_IP', default=gethostbyname(gethostname())),
+                public_id=CloudUtils._get_environment_variable_or_fail('BIOLIB_COMPUTE_NODE_PUBLIC_ID'),
+                pybiolib_version=utils.BIOLIB_PACKAGE_VERSION,
+            ),
+            base_url=CloudUtils._get_environment_variable_or_fail('BIOLIB_BASE_URL'),
+            is_dev=os.environ.get('BIOLIB_DEV') == 'TRUE',
+            shutdown_times=ShutdownTimes(
+                auto_shutdown_time_in_seconds=CloudUtils._get_environment_variable_as_int(
+                    'BIOLIB_CLOUD_AUTO_SHUTDOWN_TIME_IN_SECONDS'
                 ),
-                s3_lfs_bucket_name=CloudUtils._get_environment_variable('BIOLIB_S3_LFS_BUCKET_NAME'),
-                max_docker_image_cache_size_bytes=CloudUtils._get_environment_variable_as_int(
-                    'BIOLIB_MAX_DOCKER_IMAGE_CACHE_SIZE_BYTES'
-                ),
-                is_dev=CloudUtils._get_environment_variable('BIOLIB_DEV').upper() == 'TRUE',
-                shutdown_times=ShutdownTimes(
-                    job_max_runtime_shutdown_time_in_seconds=CloudUtils._get_environment_variable_as_int(
-                        'BIOLIB_CLOUD_JOB_MAX_RUNTIME_IN_SECONDS'
-                    ),
-                    auto_shutdown_time_in_seconds=CloudUtils._get_environment_variable_as_int(
-                        'BIOLIB_CLOUD_AUTO_SHUTDOWN_TIME_IN_SECONDS'
-                    ),
-                )
-            )
+            ),
+        )
 
         return CloudUtils._webserver_config
 
-    # Currently only used for enclaves
-    @staticmethod
-    def log(log_message: str, level: int) -> None:
-        CloudUtils.enclave.log_message_to_log_file(log_message, level)
-
     @staticmethod
-    def deregister_and_shutdown() -> None:
-        logger.debug('Waiting 10 seconds, deregistering and shutting down...')
-
-        # Sleep for 10 seconds to ensure logs are written
-        time.sleep(10)
-
-        if utils.BIOLIB_IS_RUNNING_IN_ENCLAVE:
-            CloudUtils.enclave.deregister_and_shutdown()
-        else:
+    def deregister(error: Optional[str] = None) -> None:
+        if utils.IS_RUNNING_IN_CLOUD:
             config = CloudUtils.get_webserver_config()
             try:
-                requests.post(url=f'{config["base_url"]}/api/jobs/deregister/', json={
-                    'auth_token': config["compute_node_info"]["auth_token"],
-                    'public_id': config["compute_node_info"]["public_id"],
-                })
-            except Exception as error:  # pylint: disable=broad-except
-                logger.error(error)
+                api.client.post(
+                    authenticate=False,
+                    path='/jobs/deregister/',
+                    data={
+                        'auth_token': config['compute_node_info']['auth_token'],
+                        'public_id': config['compute_node_info']['public_id'],
+                        'error': error,
+                    },
+                )
+            except BaseException as error_object:
+                logger_no_user_data.error(f'Failed to deregister got error: {error_object}')
+        else:
+            logger_no_user_data.error('Not deregistering as environment is not cloud')
 
-            logger.debug('Shutting down...')
+    @staticmethod
+    def shutdown() -> None:
+        if utils.IS_RUNNING_IN_CLOUD:
+            logger_no_user_data.debug('Waiting 10 seconds and shutting down...')
+            # Sleep for 10 seconds to ensure logs are written
+            time.sleep(10)
+            logger_no_user_data.debug('Shutting down...')
             try:
                 subprocess.run(['sudo', 'shutdown', 'now'], check=True)
             except Exception as error:  # pylint: disable=broad-except
-                logger.error(error)
+                logger_no_user_data.error(f'Failed to shutdown got error: {error}')
+        else:
+            logger_no_user_data.error('Not running shutdown as environment is not cloud')
 
     @staticmethod
-    def finish_job(job_id) -> None:
-        config = CloudUtils.get_webserver_config()
-        try:
-            requests.post(
-                url=f'{config["base_url"]}/api/jobs/cloud/finish/',
-                json={
-                    'auth_token': config["compute_node_info"]["auth_token"],
-                    'job_id': job_id,
-                },
-                timeout=5
-            )
+    def deregister_and_shutdown() -> None:
+        logger_no_user_data.debug('Deregistering and shutting down...')
 
-        except Exception as error:  # pylint: disable=broad-except
-            logger.error(f"Could not finish job with id: {job_id}")
-            logger.error(error)
+        CloudUtils.deregister()
+        CloudUtils.shutdown()
 
     @staticmethod
-    def start_auto_shutdown_timer() -> None:
-        if not utils.IS_RUNNING_IN_CLOUD:
-            raise BioLibError('Can not start shutdown timer when not running in cloud.')
-
-        if os.path.exists(CloudUtils._auto_shutdown_timer_pid_file_name):
-            logger.debug("Re-starting the auto shutdown timer")
-            try:
-                pid = int(open(CloudUtils._auto_shutdown_timer_pid_file_name, 'r').read())
-                os.kill(pid, signal.SIGTERM)
-
-            except Exception as error:  # pylint: disable=broad-except
-                logger.warning(error)
-                logger.warning('Could not kill old auto shutdown timer')
+    def finish_cloud_job(cloud_job_id: str, system_exception_code: Optional[int], exit_code: Optional[int]) -> None:
+        if not cloud_job_id:
+            logger_no_user_data.error(
+                'Finish cloud job was called but no cloud job was supplied. '
+                f'System exception code: {system_exception_code}'
+            )
+            return
 
-        config = CloudUtils.get_webserver_config()
-        timer_process = CloudAutoShutdownTimer(
-            seconds_to_wait=config['shutdown_times']['auto_shutdown_time_in_seconds']
+        logger_no_user_data.debug(
+            f'Reporting CloudJob "{cloud_job_id}" as finished with exit code: {exit_code} '
+            f'and system exception code: {system_exception_code}'
         )
 
-        timer_process.start()
-
-        with open(CloudUtils._auto_shutdown_timer_pid_file_name, 'w') as pid_file:
-            pid_file.write(str(timer_process.pid))
+        config = CloudUtils.get_webserver_config()
+        try:
+            api.client.post(
+                authenticate=False,
+                path='/jobs/cloud/finish/',
+                retries=100,
+                data={
+                    'auth_token': config['compute_node_info']['auth_token'],
+                    'cloud_job_id': cloud_job_id,
+                    'system_exception_code': system_exception_code,
+                    'exit_code': exit_code,
+                },
+            )
+        except BaseException as error:
+            logger_no_user_data.debug(f'Failed to finish CloudJob "{cloud_job_id}" due to: {error}')
 
     @staticmethod
     def _report_availability() -> None:
@@ -189,35 +140,33 @@ class CloudUtils:
             config = CloudUtils.get_webserver_config()
             compute_node_info = config['compute_node_info']
             api_client = BiolibApiClient.get()
-            logger.debug(f'Registering with {compute_node_info} to host {api_client.base_url} at {datetime.now()}')
-
-            response: Optional[requests.Response] = None
-            max_retries = 5
-            for retry_count in range(max_retries):
-                try:
-                    response = requests.post(f'{api_client.base_url}/api/jobs/report_available/',
-                                             json=compute_node_info)
-                    break
-                except Exception as error:  # pylint: disable=broad-except
-                    logger.error(f'Self-registering failed with error: {error}')
-                    if retry_count < max_retries - 1:
-                        seconds_to_sleep = 1
-                        logger.info(f'Retrying self-registering in {seconds_to_sleep} seconds')
-                        time.sleep(seconds_to_sleep)
-
-            if not response:
-                raise BioLibError('Failed to register. Max retry limit reached')
-
+            logger_no_user_data.debug(
+                f'Registering with {compute_node_info} to host {api_client.base_url} at {datetime.now()}'
+            )
+            response = api.client.post(
+                authenticate=False,
+                path='/jobs/report_available/',
+                data=cast(Dict[str, str], compute_node_info),
+            )
             if response.status_code != 201:
-                raise Exception("Non 201 error code")
+                raise Exception('Non 201 error code')
+            else:
+                logger_no_user_data.info('Compute node registered!')
+                response_data = response.json()
+                logger_no_user_data.info(f'Got data on register: {json.dumps(response_data)}')
+                certs = []
+                for federation in response_data['federation']:
+                    for cert_b64 in federation['certs_b64']:
+                        certs.append(base64.b64decode(cert_b64).decode())
+                trust_ceritificates(certs)
 
         except Exception as exception:  # pylint: disable=broad-except
-            logger.error(f'Shutting down as self register failed due to: {exception}')
+            logger_no_user_data.error(f'Shutting down as self register failed due to: {exception}')
             if not utils.IS_DEV:
                 CloudUtils.deregister_and_shutdown()
 
     @staticmethod
-    def _get_environment_variable(key: str) -> str:
+    def _get_environment_variable_or_fail(key: str) -> str:
         value = os.environ.get(key)
         # Purposely loose falsy check (instead of `is not None`) as empty string should fail
         if not value:
@@ -227,4 +176,4 @@ class CloudUtils:
 
     @staticmethod
     def _get_environment_variable_as_int(key: str) -> int:
-        return int(CloudUtils._get_environment_variable(key))
+        return int(CloudUtils._get_environment_variable_or_fail(key))

biolib/compute_node/job_worker/cache_state.py

@@ -1,104 +1,60 @@
-import abc
 import json
 import os
 import shutil
-import time
 import uuid
-from datetime import datetime
 
-import appdirs  # type: ignore
-
-from biolib.biolib_errors import BioLibError
+from biolib.biolib_logging import logger_no_user_data
 from biolib.compute_node.job_worker.cache_types import LfsCacheStateDict, UuidStr, StoragePartition, \
     DockerImageCacheStateDict
-from biolib.typing_utils import Dict, List, Optional, Generic, TypeVar
-
-
-class CacheStateError(BioLibError):
-    pass
+from biolib.typing_utils import Dict, List, cast, Optional
+from biolib.utils.cache_state import CacheState, CacheStateError
 
 
 class DockerCacheStateError(CacheStateError):
     pass
 
 
-StateType = TypeVar('StateType')
+class LfsCacheState(CacheState):
 
+    def __init__(self) -> None:
+        super().__init__()
 
-class CacheState(abc.ABC, Generic[StateType]):
-    _cache_dir: str = appdirs.user_cache_dir(appname='pybiolib', appauthor='biolib')
+        self._storage_path_for_write: str = self._get_storage_path_for_write()
+        self._storage_paths: List[str] = self._get_storage_paths()
+        self._tmp_storage_paths: List[str] = self._get_tmp_storage_paths()
 
     @property
-    @abc.abstractmethod
-    def _state_path(self) -> str:
-        raise NotImplementedError
+    def storage_paths(self) -> List[str]:
+        return self._storage_paths
 
     @property
-    @abc.abstractmethod
-    def _state_lock_path(self) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def _get_default_state(self) -> StateType:
-        raise NotImplementedError
-
-    def __init__(self):
-        self._state: Optional[StateType] = None
+    def storage_path_for_write(self) -> str:
+        return self._storage_path_for_write
 
-    def __enter__(self) -> StateType:
-        self._acquire_state_lock()
-        if os.path.exists(self._state_path):
-            with open(self._state_path, mode='r') as file:
-                self._state = json.loads(file.read())
-        else:
-            self._state = self._get_default_state()
-            with open(self._state_path, mode='w') as file:
-                file.write(json.dumps(self._state))
-
-        # Check for type checking
-        if self._state is None:
-            raise CacheStateError('Internal state is not defined')
-
-        return self._state
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        with open(self._state_path, mode='w') as file:
-            file.write(json.dumps(self._state))
-
-        self._release_state_lock()
-
-    def _acquire_state_lock(self) -> None:
-        timeout_seconds = 5.0
-        seconds_to_sleep = 0.5
-        while os.path.exists(self._state_lock_path):
-            time.sleep(seconds_to_sleep)
-            timeout_seconds -= seconds_to_sleep
-            if timeout_seconds < 0:
-                raise CacheStateError('Cache state timed out waiting for lock file')
-
-        os.makedirs(self._cache_dir, exist_ok=True)
-        lock_file = open(self._state_lock_path, mode='x')
-        lock_file.close()
-
-    def _release_state_lock(self) -> None:
-        if os.path.exists(self._state_lock_path):
-            os.remove(self._state_lock_path)
-        else:
-            raise CacheStateError('Cache state was not locked.')
-
-    @staticmethod
-    def get_timestamp_now() -> str:
-        return datetime.now().isoformat()
+    @property
+    def tmp_storage_paths(self) -> List[str]:
+        return self._tmp_storage_paths
 
+    @property
+    def main_lfs_storage_path(self) -> str:
+        return self._storage_paths[0]
 
-class LfsCacheState(CacheState):
     @property
     def _state_path(self) -> str:
-        return f'{super()._cache_dir}/lfs-cache-state.json'
+        state_path = os.environ.get('BIOLIB_LFS_STATE_PATH')
+        if not state_path:
+            raise CacheStateError('Environment variable "BIOLIB_LFS_STATE_PATH" not set')
 
-    @property
-    def _state_lock_path(self) -> str:
-        return f'{self._state_path}.lock'
+        return state_path
+
+    def get_read_only_dict_without_lock(self) -> Optional[LfsCacheStateDict]:
+        try:
+            if not os.path.isfile(self._state_path):
+                return None
+            with open(self._state_path, mode='r') as file:
+                return cast(LfsCacheStateDict, json.load(file))
+        except BaseException:
+            return None
 
     def _get_default_state(self) -> LfsCacheStateDict:
         return LfsCacheStateDict(
@@ -107,26 +63,52 @@ class LfsCacheState(CacheState):
         )
 
     @staticmethod
-    def get_tmp_storage_paths() -> List[str]:
+    def _get_tmp_storage_paths() -> List[str]:
         lfs_tmp_storage_path_env_key = 'BIOLIB_LFS_TMP_STORAGE_PATHS'
         lfs_tmp_storage_paths = os.environ.get(lfs_tmp_storage_path_env_key)
-        if lfs_tmp_storage_paths is None:
+        if not lfs_tmp_storage_paths:
             raise CacheStateError(f'Environment variable "{lfs_tmp_storage_path_env_key}" not set')
 
-        return lfs_tmp_storage_paths.split(',')
+        lfs_tmp_storage_paths_list = lfs_tmp_storage_paths.split(',')
+        for lfs_tmp_storage_path in lfs_tmp_storage_paths_list:
+            if not os.path.isdir(lfs_tmp_storage_path):
+                raise CacheStateError(f'LFS temporary storage path {lfs_tmp_storage_path} is not a directory')
+
+        return lfs_tmp_storage_paths_list
 
     @staticmethod
-    def _get_storage_partitions_from_env() -> Dict[UuidStr, StoragePartition]:
+    def _get_storage_paths() -> List[str]:
         lfs_storage_path_env_key = 'BIOLIB_LFS_STORAGE_PATHS'
         lfs_storage_paths = os.environ.get(lfs_storage_path_env_key)
-        if lfs_storage_paths is None:
+        logger_no_user_data.debug(f'LFS storage paths: {lfs_storage_paths}')
+
+        # It is essential to check like this so we catch if it is None and if it is empty string
+        if not lfs_storage_paths:
             raise CacheStateError(f'Environment variable "{lfs_storage_path_env_key}" not set')
 
-        storage_states: Dict[UuidStr, StoragePartition] = {}
-        for lfs_storage_path in lfs_storage_paths.split(','):
+        lfs_storage_paths_list = lfs_storage_paths.split(',')
+        for lfs_storage_path in lfs_storage_paths_list:
             if not os.path.isdir(lfs_storage_path):
                 raise CacheStateError(f'LFS storage path {lfs_storage_path} is not a directory')
 
+        return lfs_storage_paths_list
+
+    @staticmethod
+    def _get_storage_path_for_write() -> str:
+        lfs_storage_path_for_write = os.environ.get('BIOLIB_LFS_WRITE_STORAGE_PATH')
+        logger_no_user_data.debug(f'lfs_storage_path_for_write={lfs_storage_path_for_write}')
+
+        if not lfs_storage_path_for_write:
+            raise CacheStateError('Environment variable "BIOLIB_LFS_WRITE_STORAGE_PATH" not set')
+
+        if not os.path.isdir(lfs_storage_path_for_write):
+            raise CacheStateError(f'LFS storage path {lfs_storage_path_for_write} is not a directory')
+
+        return lfs_storage_path_for_write
+
+    def _get_storage_partitions_from_env(self) -> Dict[UuidStr, StoragePartition]:
+        storage_states: Dict[UuidStr, StoragePartition] = {}
+        for lfs_storage_path in self._storage_paths:
             uuid_str = str(uuid.uuid4())
             disk_usage = shutil.disk_usage(lfs_storage_path)
             storage_states[uuid_str] = StoragePartition(
@@ -142,11 +124,7 @@ class LfsCacheState(CacheState):
 class DockerImageCacheState(CacheState):
     @property
     def _state_path(self) -> str:
-        return f'{super()._cache_dir}/docker-cache-state.json'
-
-    @property
-    def _state_lock_path(self) -> str:
-        return f'{self._state_path}.lock'
+        return f'{self._user_cache_dir}/docker-cache-state.json'
 
     def _get_default_state(self) -> DockerImageCacheStateDict:
         return {}

biolib/compute_node/job_worker/cache_types.py

@@ -6,7 +6,6 @@ DockerImageUri = str
 
 
 class LargeFileSystemCache(TypedDict):
-    active_jobs: List[UuidStr]
     last_used_at: str
     size_bytes: int
     state: Literal['downloading', 'ready']
@@ -26,15 +25,11 @@ class LfsCacheStateDict(TypedDict):
     large_file_systems: Dict[UuidStr, LargeFileSystemCache]
 
 
-class DockerAuthConfig(TypedDict):
-    username: str
-    password: str
-
-
 class DockerImageInfo(TypedDict):
     last_used_at: str
     estimated_image_size_bytes: int
     state: Literal['pulling', 'ready']
+    active_jobs: List[UuidStr]
     uri: str