rbx.cp 0.5.39__py3-none-any.whl → 0.5.42__py3-none-any.whl

rbx/grading/steps.py

@@ -1,10 +1,16 @@
+import asyncio
+import contextlib
+import dataclasses
 import functools
+import os
 import pathlib
 import re
 import shlex
 import shutil
 import subprocess
 import sys
+import tempfile
+import typing
 from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -123,6 +129,8 @@ class GradingFileOutput(BaseModel):
     intermediate: bool = False
     # Whether to track file through its hash (disable for optimization).
     hash: bool = True
+    # Whether to touch the file before the command runs.
+    touch: bool = False
 
     def get_file(self, storage: Storage) -> Optional[IO[bytes]]:
         if self.dest is not None:
@@ -136,6 +144,15 @@ class GradingFileOutput(BaseModel):
         raise ValueError('No file to get')
 
 
+class GradingFifo(BaseModel):
+    # Destination path relative to the sandbox.
+    path: pathlib.Path
+    # Symlink to the FIFO outside the sandbox.
+    symlink: Optional[pathlib.Path] = None
+    # Whether to create the FIFO if it does not exist.
+    create: bool = True
+
+
 class GradingArtifacts(BaseModel):
     # Root directory for the produced artifacts.
     root: pathlib.Path = pathlib.PosixPath('.')
@@ -143,6 +160,8 @@ class GradingArtifacts(BaseModel):
     inputs: List[GradingFileInput] = []
     # List of output files to copy from the sandbox.
     outputs: List[GradingFileOutput] = []
+    # List of FIFOs
+    fifos: List[GradingFifo] = []
     # Capture certain logs of the execution.
     logs: Optional[GradingLogsHolder] = None
 
@@ -241,6 +260,14 @@ def _process_input_artifacts(artifacts: GradingArtifacts, sandbox: SandboxBase):
             override=True,
             try_symlink=True,
         )
+    for output_artifact in artifacts.outputs:
+        if output_artifact.touch:
+            sandbox.create_file_from_string(
+                output_artifact.src,
+                '',
+                executable=output_artifact.executable,
+                override=True,
+            )
 
 
 def _process_output_artifacts(
@@ -278,6 +305,14 @@ def _process_output_artifacts(
     return True
 
 
+def _process_fifos(artifacts: GradingArtifacts, sandbox: SandboxBase):
+    for fifo in artifacts.fifos:
+        if fifo.symlink is not None:
+            sandbox.create_symlink(fifo.path, fifo.symlink, override=True)
+        else:
+            sandbox.create_fifo(fifo.path, override=True)
+
+
 def testlib_grading_input() -> GradingFileInput:
     return GradingFileInput(src=get_testlib(), dest=pathlib.Path('testlib.h'))
 
@@ -553,7 +588,7 @@ def compile(
     return _process_output_artifacts(artifacts, sandbox)
 
 
-def run(
+async def run(
     command: str,
     params: SandboxParams,
     sandbox: SandboxBase,
@@ -561,10 +596,11 @@ def run(
     metadata: Optional[RunLogMetadata] = None,
 ) -> Optional[RunLog]:
     _process_input_artifacts(artifacts, sandbox)
+    _process_fifos(artifacts, sandbox)
     cmd = _split_and_expand(command, sandbox)
     sandbox.set_params(params)
 
-    if not sandbox.execute_without_std(cmd):
+    if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
         console.print(
             '[error]Sandbox crashed while processing command:[/error]',
             utils.highlight_json_obj(cmd),
@@ -600,6 +636,34 @@ def run(
     return run_log
 
 
+@dataclasses.dataclass
+class CoordinatedRunParams:
+    command: str
+    params: SandboxParams
+    sandbox: SandboxBase
+    artifacts: GradingArtifacts
+    metadata: Optional[RunLogMetadata] = None
+
+
+async def run_coordinated(
+    interactor: CoordinatedRunParams,
+    solution: CoordinatedRunParams,
+) -> Tuple[Optional[RunLog], Optional[RunLog]]:
+    runs = tuple(
+        run(
+            params.command,
+            params.params,
+            params.sandbox,
+            params.artifacts,
+            params.metadata,
+        )
+        for params in [interactor, solution]
+    )
+    return typing.cast(
+        Tuple[Optional[RunLog], Optional[RunLog]], tuple(await asyncio.gather(*runs))
+    )
+
+
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:
     return tuple(s.split())
 
@@ -722,3 +786,13 @@ def evaluate(
         log=log,
         result=checker_result,
     )
+
+
+@contextlib.contextmanager
+def make_fifos():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        fifo_in = pathlib.PosixPath(temp_dir) / 'fifo.in'
+        fifo_out = pathlib.PosixPath(temp_dir) / 'fifo.out'
+        os.mkfifo(fifo_in)
+        os.mkfifo(fifo_out)
+        yield fifo_in, fifo_out

rbx/grading/steps_with_caching.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from rbx.grading import steps
 from rbx.grading.caching import DependencyCache, NoCacheException
@@ -11,6 +11,12 @@ from rbx.grading.steps import (
 )
 
 
+def _get_prefixed_cacheable_params(
+    params: Dict[str, Any], prefix: str
+) -> Dict[str, Any]:
+    return {f'{prefix}.{k}': v for k, v in params.items()}
+
+
 def compile(
     commands: List[str],
     params: SandboxParams,
@@ -36,7 +42,7 @@ def compile(
     return ok
 
 
-def run(
+async def run(
     command: str,
     params: SandboxParams,
     sandbox: SandboxBase,
@@ -52,7 +58,7 @@ def run(
 
     with dependency_cache([command], [artifacts], cacheable_params) as is_cached:
         if not is_cached:
-            steps.run(
+            await steps.run(
                 command=command,
                 params=params,
                 artifacts=artifacts,
@@ -61,3 +67,39 @@ def run(
             )
 
     return artifacts.logs.run
+
+
+async def run_coordinated(
+    interactor: steps.CoordinatedRunParams,
+    solution: steps.CoordinatedRunParams,
+    dependency_cache: DependencyCache,
+) -> Tuple[Optional[RunLog], Optional[RunLog]]:
+    interactor.artifacts.logs = GradingLogsHolder()
+    solution.artifacts.logs = GradingLogsHolder()
+
+    cacheable_params = {
+        **_get_prefixed_cacheable_params(
+            interactor.params.get_cacheable_params(), 'interactor'
+        ),
+        **_get_prefixed_cacheable_params(
+            solution.params.get_cacheable_params(), 'solution'
+        ),
+    }
+
+    if interactor.metadata is not None and interactor.metadata.retryIndex is not None:
+        cacheable_params['interactor.__retry_index__'] = interactor.metadata.retryIndex
+    if solution.metadata is not None and solution.metadata.retryIndex is not None:
+        cacheable_params['solution.__retry_index__'] = solution.metadata.retryIndex
+
+    with dependency_cache(
+        [interactor.command, solution.command],
+        [interactor.artifacts, solution.artifacts],
+        cacheable_params,
+    ) as is_cached:
+        if not is_cached:
+            await steps.run_coordinated(interactor, solution)
+
+    return (
+        interactor.artifacts.logs.run,
+        solution.artifacts.logs.run,
+    )

rbx/grading/steps_with_caching_run_test.py

@@ -15,7 +15,7 @@ from rbx.grading.steps import (
 )
 
 
-def test_run_from_digest(
+async def test_run_from_digest(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
@@ -29,7 +29,7 @@ def test_run_from_digest(
     artifacts.outputs.append(
         GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=pathlib.Path('out.txt'))
     )
-    steps_with_caching.run(
+    await steps_with_caching.run(
         f'{sys.executable} executable.py',
         params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
         sandbox=sandbox,
@@ -45,7 +45,7 @@ def test_run_from_digest(
     assert not artifacts.logs.cached
 
 
-def test_run_from_disk(
+async def test_run_from_disk(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
@@ -60,7 +60,7 @@ def test_run_from_disk(
     artifacts.outputs.append(
         GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=pathlib.Path('out.txt'))
     )
-    steps_with_caching.run(
+    await steps_with_caching.run(
         f'{sys.executable} executable.py',
         params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
         sandbox=sandbox,
@@ -74,13 +74,13 @@ def test_run_from_disk(
     assert not artifacts.logs.cached
 
 
-def test_run_caches_intermediate_digest_if_dest_changes(
+async def test_run_caches_intermediate_digest_if_dest_changes(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -89,7 +89,7 @@ def test_run_caches_intermediate_digest_if_dest_changes(
         artifacts.outputs.append(
             GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -98,24 +98,26 @@ def test_run_caches_intermediate_digest_if_dest_changes(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('another-out.txt'))
+    another_artifacts = await configure_and_run_with_dest(
+        pathlib.Path('another-out.txt')
+    )
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
 
 
-def test_run_overwrite_changed_file_with_storage_value(
+async def test_run_overwrite_changed_file_with_storage_value(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -124,7 +126,7 @@ def test_run_overwrite_changed_file_with_storage_value(
         artifacts.outputs.append(
             GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -133,26 +135,26 @@ def test_run_overwrite_changed_file_with_storage_value(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').write_text('42')
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
 
 
-def test_run_recreates_deleted_file_with_storage_value(
+async def test_run_recreates_deleted_file_with_storage_value(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -161,7 +163,7 @@ def test_run_recreates_deleted_file_with_storage_value(
         artifacts.outputs.append(
             GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -170,26 +172,26 @@ def test_run_recreates_deleted_file_with_storage_value(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').unlink()
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
 
 
-def test_run_overwrite_exec_bit_when_changed(
+async def test_run_overwrite_exec_bit_when_changed(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -203,7 +205,7 @@ def test_run_overwrite_exec_bit_when_changed(
                 src=pathlib.Path('box-out.txt'), dest=dest, executable=True
             )
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -212,7 +214,7 @@ def test_run_overwrite_exec_bit_when_changed(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
@@ -220,20 +222,20 @@ def test_run_overwrite_exec_bit_when_changed(
 
     pathlib.Path('out.txt').chmod(0o644)
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
     assert os.access('out.txt', os.X_OK)
 
 
-def test_run_evicts_when_changed_file_and_no_hash(
+async def test_run_evicts_when_changed_file_and_no_hash(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -242,7 +244,7 @@ def test_run_evicts_when_changed_file_and_no_hash(
         artifacts.outputs.append(
             GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest, hash=False)
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -251,26 +253,26 @@ def test_run_evicts_when_changed_file_and_no_hash(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').write_text('42')
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert not another_artifacts.logs.cached
 
 
-def test_run_evicts_when_exec_bit_different_and_no_hash(
+async def test_run_evicts_when_exec_bit_different_and_no_hash(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
         executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -281,7 +283,7 @@ def test_run_evicts_when_exec_bit_different_and_no_hash(
                 src=pathlib.Path('box-out.txt'), dest=dest, hash=False, executable=True
             )
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -290,25 +292,25 @@ def test_run_evicts_when_exec_bit_different_and_no_hash(
         )
         return artifacts
 
-    artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').chmod(0o0644)
 
-    another_artifacts = configure_and_run_with_dest(pathlib.Path('out.txt'))
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert not another_artifacts.logs.cached
 
 
-def test_run_evicts_when_input_fingerprint_changes(
+async def test_run_evicts_when_input_fingerprint_changes(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
 ):
-    def configure_and_run() -> GradingArtifacts:
+    async def configure_and_run() -> GradingArtifacts:
         executable = DigestOrSource.create(pathlib.Path('executable.py'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -320,7 +322,7 @@ def test_run_evicts_when_input_fingerprint_changes(
                 dest=pathlib.Path('out.txt'),
             )
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -331,25 +333,25 @@ def test_run_evicts_when_input_fingerprint_changes(
 
     pathlib.Path('executable.py').write_text('print(5)')
 
-    artifacts = configure_and_run()
+    artifacts = await configure_and_run()
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('executable.py').write_text('print(42)')
 
-    another_artifacts = configure_and_run()
+    another_artifacts = await configure_and_run()
     assert (cleandir / 'out.txt').read_text().strip() == '42'
     assert another_artifacts.logs is not None
     assert not another_artifacts.logs.cached
 
 
-def test_run_evicts_when_output_is_deleted_and_no_hash(
+async def test_run_evicts_when_output_is_deleted_and_no_hash(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
 ):
-    def configure_and_run() -> GradingArtifacts:
+    async def configure_and_run() -> GradingArtifacts:
         executable = DigestOrSource.create(pathlib.Path('executable.py'))
         artifacts = GradingArtifacts()
         artifacts.inputs.append(
@@ -362,7 +364,7 @@ def test_run_evicts_when_output_is_deleted_and_no_hash(
                 hash=False,
             )
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -373,26 +375,26 @@ def test_run_evicts_when_output_is_deleted_and_no_hash(
 
     pathlib.Path('executable.py').write_text('print(5)')
 
-    artifacts = configure_and_run()
+    artifacts = await configure_and_run()
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').unlink()
 
-    another_artifacts = configure_and_run()
+    another_artifacts = await configure_and_run()
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert not another_artifacts.logs.cached
 
 
-def test_run_misses_when_input_file_changes(
+async def test_run_misses_when_input_file_changes(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
     file_cacher: FileCacher,
 ):
-    def configure_and_run(number: int) -> GradingArtifacts:
+    async def configure_and_run(number: int) -> GradingArtifacts:
         executable = DigestOrSource.create(
             file_cacher.put_file_text(f'print({number})')
         )
@@ -407,7 +409,7 @@ def test_run_misses_when_input_file_changes(
                 hash=False,
             )
         )
-        steps_with_caching.run(
+        await steps_with_caching.run(
             f'{sys.executable} executable.py',
             params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
             sandbox=sandbox,
@@ -416,14 +418,14 @@ def test_run_misses_when_input_file_changes(
         )
         return artifacts
 
-    artifacts = configure_and_run(5)
+    artifacts = await configure_and_run(5)
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
     pathlib.Path('out.txt').write_text('42')
 
-    another_artifacts = configure_and_run(42)
+    another_artifacts = await configure_and_run(42)
     assert (cleandir / 'out.txt').read_text().strip() == '42'
     assert another_artifacts.logs is not None
     assert not another_artifacts.logs.cached