runtime: Add Pull-Only labs runtime implementation

New PULL_LABS runtime for KernelCI that implements the
Job Definition creation according to the PULL_LABS protocol
specification.

New files:
kernelci/runtime/pull_labs.py - Main runtime implementation
config/runtime/base/pull_labs.jinja2 - JSON job definition template

kernelci/config/runtime.py - Added RuntimePullLabs configuration class
Properties: poll_interval, timeout, storage_name
Registered in RuntimeFactory._lab_types as 'pull_labs'

Signed-off-by: Denys Fedoryshchenko <[email protected]>

Author: nuclearcat

config/runtime/base/pull_labs.jinja2

@@ -0,0 +1,97 @@
+{# SPDX-License-Identifier: LGPL-2.1-or-later -#}
+{# PULL_LABS job definition template - generates JSON format #}
+{# This template creates a job definition according to PULL_LABS protocol Section 3 #}
+{
+  "artifacts": {
+{%- set artifacts_entries = [] %}
+{%- if node.artifacts.kernel %}
+{%-   do artifacts_entries.append('    "kernel": "' ~ node.artifacts.kernel ~ '"') %}
+{%- endif %}
+{%- if node.artifacts.modules %}
+{%-   do artifacts_entries.append('    "modules": "' ~ node.artifacts.modules ~ '"') %}
+{%- endif %}
+{%- if node.artifacts.kselftest %}
+{%-   do artifacts_entries.append('    "kselftest": "' ~ node.artifacts.kselftest ~ '"') %}
+{%- endif %}
+{%- if ramdisk %}
+{%-   do artifacts_entries.append('    "ramdisk": "' ~ ramdisk ~ '"') %}
+{%- endif %}
+{%- if nfsroot is defined and nfsroot %}
+{%-   do artifacts_entries.append('    "nfsroot": "' ~ nfsroot ~ '"') %}
+{%- endif %}
+{%- if node.artifacts.initrd %}
+{%-   do artifacts_entries.append('    "initrd": "' ~ node.artifacts.initrd ~ '"') %}
+{%- endif %}
+{%- if node.artifacts.dtb %}
+{%-   do artifacts_entries.append('    "dtb": "' ~ node.artifacts.dtb ~ '"') %}
+{%- endif %}
+{%- if artifacts_entries %}
+{{ artifacts_entries | join(',\n') }}
+{%- endif %}
+  },
+  "tests": [
+{%- if test_definitions %}
+{%- for test in test_definitions %}
+    {
+      "id": "{{ test.id }}",
+      "type": "{{ test.type }}",
+      "depends": {{ test.depends | tojson }},
+      "timeout_s": {{ test.timeout_s | default(600) }}
+{%- if test.subset %},
+      "subset": {{ test.subset | tojson }}
+{%- endif %}
+{%- if test.parameters %},
+      "parameters": "{{ test.parameters }}"
+{%- endif %}
+{%- if test.pre_commands %},
+      "pre-commands": {{ test.pre_commands | tojson }}
+{%- else %},
+      "pre-commands": []
+{%- endif %}
+{%- if test.post_commands %},
+      "post-commands": {{ test.post_commands | tojson }}
+{%- else %},
+      "post-commands": []
+{%- endif %}
+    }{{ "," if not loop.last else "" }}
+{%- endfor %}
+{%- else %}
+    {
+      "id": "boot-test-{{ node.id[:8] }}",
+      "type": "boot",
+      "depends": [],
+      "timeout_s": 600,
+      "pre-commands": [],
+      "post-commands": []
+    }
+{%- endif %}
+  ],
+  "environment": {
+    "platform": "{{ platform_config.name }}",
+    "arch": "{{ platform_config.arch }}",
+    "console": {
+      "method": "{{ platform_config.console_method | default('serial') }}",
+      "baud": {{ platform_config.console_baud | default(115200) }}
+    }
+{%- if platform_config.params and platform_config.params.requirements %}
+    ,"requirements": {{ platform_config.params.requirements | tojson }}
+{%- endif %}
+  },
+  "callback": {
+    "url": "{{ instance_callback }}/node/{{ node.id }}",
+    "token_name": "{{ callback_token_name | default('kernelci-pipeline-callback') }}"
+  }
+{%- if node.artifacts.metadata %}
+  ,"integrity": {
+    "sha256": {
+{%- if checksums %}
+{%- for artifact_name, checksum in checksums.items() %}
+      "{{ artifact_name }}": "{{ checksum }}"{{ "," if not loop.last else "" }}
+{%- endfor %}
+{%- else %}
+      "_comment": "Checksums would be populated from metadata.json if available"
+{%- endif %}
+    }
+  }
+{%- endif %}
+}

kernelci/config/runtime.py

@@ -2,6 +2,9 @@
 #
 # Copyright (C) 2019, 2021-2023 Collabora Limited
 # Author: Guillaume Tucker <[email protected]>
+#
+# Copyright (C) 2025 Collabora Limited
+# Author: Denys Fedoryshchenko <[email protected]>
 
 """KernelCI Runtime environment configuration"""
 
@@ -11,7 +14,7 @@
 class Runtime(YAMLConfigObject):
     """Runtime environment configuration"""
 
-    yaml_tag = '!Runtime'
+    yaml_tag = "!Runtime"
 
     def __init__(self, name, lab_type, filters=None, rules=None):
         """A runtime environment configuration object
@@ -44,25 +47,24 @@ def rules(self):
     @classmethod
     def _get_yaml_attributes(cls):
         attrs = super()._get_yaml_attributes()
-        attrs.update({'lab_type', 'rules'})
+        attrs.update({"lab_type", "rules"})
         return attrs
 
     @classmethod
     def _to_yaml_dict(cls, data):
-        yaml_dict = {
-            key: getattr(data, key)
-            for key in cls._get_yaml_attributes()
-        }
-        yaml_dict.update({
-            # pylint: disable=protected-access
-            'filters': [{fil.name: fil} for fil in data._filters],
-        })
+        yaml_dict = {key: getattr(data, key) for key in cls._get_yaml_attributes()}
+        yaml_dict.update(
+            {
+                # pylint: disable=protected-access
+                "filters": [{fil.name: fil} for fil in data._filters],
+            }
+        )
         return yaml_dict
 
     @classmethod
     def to_yaml(cls, dumper, data):
         return dumper.represent_mapping(
-            'tag:yaml.org,2002:map', cls._to_yaml_dict(data)
+            "tag:yaml.org,2002:map", cls._to_yaml_dict(data)
         )
 
     def match(self, data):
@@ -73,19 +75,26 @@ def match(self, data):
 class RuntimeLAVA(Runtime):
     """Configuration for LAVA runtime environments"""
 
-    yaml_tag = '!RuntimeLAVA'
+    yaml_tag = "!RuntimeLAVA"
 
     PRIORITIES = {
-        'low': 0,
-        'medium': 50,
-        'high': 100,
+        "low": 0,
+        "medium": 50,
+        "high": 100,
     }
 
     # This should be solved by dropping the "priority" attribute
     # pylint: disable=too-many-arguments
-    def __init__(self, url=None, priority=None, priority_min=None,
-                 priority_max=None, queue_timeout=None, notify=None,
-                 **kwargs):
+    def __init__(
+        self,
+        url=None,
+        priority=None,
+        priority_min=None,
+        priority_max=None,
+        queue_timeout=None,
+        notify=None,
+        **kwargs,
+    ):
         super().__init__(**kwargs)
 
         def _set_priority_value(value, default):
@@ -135,24 +144,25 @@ def notify(self):
     @classmethod
     def _get_yaml_attributes(cls):
         attrs = super()._get_yaml_attributes()
-        attrs.update({
-            'priority',
-            'priority_min',
-            'priority_max',
-            'queue_timeout',
-            'url',
-            'notify',
-        })
+        attrs.update(
+            {
+                "priority",
+                "priority_min",
+                "priority_max",
+                "queue_timeout",
+                "url",
+                "notify",
+            }
+        )
         return attrs
 
 
 class RuntimeDocker(Runtime):
     """Configuration for Docker runtime environments"""
 
-    yaml_tag = '!RuntimeDocker'
+    yaml_tag = "!RuntimeDocker"
 
-    def __init__(self, env_file=None, volumes=None, user=None, timeout=None,
-                 **kwargs):
+    def __init__(self, env_file=None, volumes=None, user=None, timeout=None, **kwargs):
         super().__init__(**kwargs)
         self._env_file = env_file
         self._volumes = volumes or []
@@ -182,14 +192,14 @@ def timeout(self):
     @classmethod
     def _get_yaml_attributes(cls):
         attrs = super()._get_yaml_attributes()
-        attrs.update({'env_file', 'volumes', 'user', 'timeout'})
+        attrs.update({"env_file", "volumes", "user", "timeout"})
         return attrs
 
 
 class RuntimeKubernetes(Runtime):
     """Configuration for Kubernetes runtime environments"""
 
-    yaml_tag = '!RuntimeKubernetes'
+    yaml_tag = "!RuntimeKubernetes"
 
     def __init__(self, context=None, **kwargs):
         super().__init__(**kwargs)
@@ -203,43 +213,77 @@ def context(self):
     @classmethod
     def _get_yaml_attributes(cls):
         attrs = super()._get_yaml_attributes()
-        attrs.update({'context'})
+        attrs.update({"context"})
+        return attrs
+
+
+class RuntimePullLabs(Runtime):
+    """Configuration for PULL_LABS runtime environments"""
+
+    yaml_tag = "!RuntimePullLabs"
+
+    def __init__(self, poll_interval=None, timeout=None, storage_name=None, **kwargs):
+        super().__init__(**kwargs)
+        self._poll_interval = poll_interval or 30
+        self._timeout = timeout or 3600
+        self._storage_name = storage_name
+
+    @property
+    def poll_interval(self):
+        """Polling interval for events in seconds"""
+        return self._poll_interval
+
+    @property
+    def timeout(self):
+        """Job timeout in seconds"""
+        return self._timeout
+
+    @property
+    def storage_name(self):
+        """Storage configuration name for job definitions"""
+        return self._storage_name
+
+    @classmethod
+    def _get_yaml_attributes(cls):
+        attrs = super()._get_yaml_attributes()
+        attrs.update({"poll_interval", "timeout", "storage_name"})
         return attrs
 
 
 class RuntimeFactory:  # pylint: disable=too-few-public-methods
     """Factory to create lab objects from YAML data."""
 
     _lab_types = {
-        'docker': RuntimeDocker,
-        'kubernetes': RuntimeKubernetes,
-        'lava': RuntimeLAVA,
-        'legacy.lava_xmlrpc': RuntimeLAVA,
-        'legacy.lava_rest': RuntimeLAVA,
-        'shell': Runtime,
+        "docker": RuntimeDocker,
+        "kubernetes": RuntimeKubernetes,
+        "lava": RuntimeLAVA,
+        "legacy.lava_xmlrpc": RuntimeLAVA,
+        "legacy.lava_rest": RuntimeLAVA,
+        "pull_labs": RuntimePullLabs,
+        "shell": Runtime,
     }
 
     @classmethod
     def from_yaml(cls, name, config, default_filters):
         """Load the configuration from YAML data"""
-        lab_type = config.get('lab_type')
+        lab_type = config.get("lab_type")
         kwargs = {
-            'name': name,
-            'lab_type': lab_type,
-            'filters': FilterFactory.from_data(config, default_filters),
+            "name": name,
+            "lab_type": lab_type,
+            "filters": FilterFactory.from_data(config, default_filters),
         }
         lab_cls = cls._lab_types[lab_type] if lab_type else Runtime
         return lab_cls.load_from_yaml(config, **kwargs)
 
 
 def from_yaml(data, filters):
     """Load the runtime environment from YAML based on its type"""
-    runtimes_filters = filters.get('runtimes')
+    runtimes_filters = filters.get("runtimes")
     runtimes = {
         name: RuntimeFactory.from_yaml(name, runtime, runtimes_filters)
-        for name, runtime in data.get('runtimes', {}).items()
+        for name, runtime in data.get("runtimes", {}).items()
     }
 
     return {
-        'runtimes': runtimes,
+        "runtimes": runtimes,
     }

kernelci/runtime/__init__.py

@@ -15,7 +15,7 @@
 
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 
-from kernelci.config.base import get_system_arch
+from kernelci.config.base import get_system_arch, _format_dict_strings
 
 
 class Job:
@@ -179,14 +179,28 @@ def get_params(self, job, api_config=None):
             'runtime_image': job.config.image,
             'device_type': device_type,
         }
-        if job.platform_config.params:
-            params.update(job.platform_config.params)
-        if device_dtb:
-            params['device_dtb'] = device_dtb
-        params.update(job.config.params)
-        arch = params.get('arch') or job.platform_config.arch
+        platform_params = job.platform_config.params or {}
+        job_params = job.config.params
+        arch = (
+            (job_params.get('arch') if job_params else None)
+            or platform_params.get('arch')
+            or job.platform_config.arch
+        )
+        params['arch'] = arch
         for system in ('brarch', 'crosarch', 'debarch', 'karch'):
             params.update({system: get_system_arch(system, arch)})
+        if platform_params:
+            platform_map = params.copy()
+            platform_map.update(platform_params)
+            formatted_platform_params = _format_dict_strings(platform_params.copy(), platform_map)
+            params.update(formatted_platform_params)
+        if device_dtb:
+            params['device_dtb'] = device_dtb
+        if job_params:
+            job_map = params.copy()
+            job_map.update(job_params)
+            formatted_job_params = _format_dict_strings(job_params.copy(), job_map)
+            params.update(formatted_job_params)
         return params
 
     @classmethod