Migrated from GitHub

data/.arcconfig

@@ -0,0 +1,7 @@
+{
+    "project_id" : "resultsdb",
+    "conduit_uri" : "https://phab.qa.fedoraproject.org",
+    "arc.land.onto.default" : "develop",
+    "arc.feature.start.default" : "develop",
+    "unit.engine" : "PytestTestEngine"
+}

data/.arclint

@@ -0,0 +1,13 @@
+{
+  "linters": {
+    "flake8": {
+      "type": "flake8",
+      "include": "(\\.py$)",
+      "severity.rules": {
+        "(E501)": "disabled",
+        "(^E)": "warning",
+        "(^F)": "error"
+      }
+    }
+  }
+}

data/.coveragerc

@@ -0,0 +1,5 @@
+[run]
+branch = True
+
+[report]
+fail_under = 80

data/.dockerignore

@@ -0,0 +1,3 @@
+.*_cache/
+**/__pycache__/
+*.egg-info/

data/.pre-commit-config.yaml

@@ -0,0 +1,87 @@
+---
+ci:
+  autoupdate_schedule: monthly
+  skip:
+    - hadolint-docker
+    # renovate exceeds tier max size 250MiB on pre-commit.ci
+    # (due to huge node.js dependencies)
+    - renovate-config-validator
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-merge-conflict
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  # Sort imports
+  - repo: https://github.com/pycqa/isort
+    rev: 6.0.1
+    hooks:
+      - id: isort
+        name: isort
+        args:
+          - --line-length=79
+          - --profile=black
+
+  # Remove unused imports, variables, statements
+  - repo: https://github.com/PyCQA/autoflake
+    rev: v2.3.1
+    hooks:
+      - id: autoflake
+
+  # Auto-update syntax
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.20.0
+    hooks:
+      - id: pyupgrade
+        args:
+          - --py313-plus
+
+  # Linter and formatter
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.4
+    hooks:
+      - id: ruff
+        args:
+          # ignore: E501 Line too long
+          - --ignore=E501
+      - id: ruff-format
+
+  # Linter and formatter
+  - repo: https://github.com/Instagram/Fixit
+    rev: v2.1.0
+    hooks:
+      - id: fixit-fix
+
+  # Type linter
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.17.0
+    hooks:
+      - id: mypy
+        args:
+          - --disable-error-code=import-untyped
+          - --ignore-missing-imports
+
+  # Security linter
+  - repo: https://github.com/pycqa/bandit
+    rev: 1.8.6
+    hooks:
+      - id: bandit
+        name: bandit
+        exclude: tests/
+
+  # Dockerfile linter
+  - repo: https://github.com/hadolint/hadolint
+    rev: v2.13.1-beta
+    hooks:
+      - id: hadolint-docker
+
+  # renovate.json validator
+  - repo: https://github.com/renovatebot/pre-commit-hooks
+    rev: 41.40.0
+    hooks:
+      - id: renovate-config-validator

data/.taskotron_task_dockerbuild.json

@@ -0,0 +1 @@
+{"docker_project_name": "resultsdb", "docker_credentials_bucket_uuid": "1e77148e-64ab-11e8-8f59-525400ee7c53", "release_branch": "master"}

data/APIDOCS.apiary

@@ -0,0 +1,620 @@
+[comment0]: # (Apiary only does GitHub synchronization. This is here so we can have the data outside of "closed" app. Also, feel free to post patches against this file for docs changes.)
+[comment1]: # (Last updated: Tue Jan 31, 17:55)
+
+FORMAT: 1A
+HOST: https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/
+
+# ResultsDB 2.0
+
+ResultsDB is an independent system for storing results, originaly written as a part of [Taskotron](https://taskotron.fedoraproject.org/) automation tool.
+
+Source code: https://bitbucket.org/account/user/fedoraqa/projects/RES
+
+## Changes since 1.0
+
+* Removed `Jobs` and replaced with `Groups` to remove the "execution status" (originaly represented by `Job`) from ResultsDB,
+  but keeping the ability to group `Results`, as it might make semantical sense
+    * `Result` can be a part of 0-n `Groups`
+    * UUID as a default `Group` identifier instead of `id`
+* In the response data:
+    *`href` (pointer to `self`) is only present in the resource's data, not in the general queries that return collections, since the 'search' queries' `href` was not permalink
+    * `ref_url` as a common "external url" attribute
+        * `Result.ref_url` instead of `Result.log_url`
+        * `Testcase.ref_url` instead of `Testcase.url`
+* Changes in the `Group` object
+    * `results` is an URL at which `Results` in that particular `Group` can be
+    * `name` renamed to `description`
+* Changes in the `Result` object
+    * `ref_url` instead of `log_url`
+    * `result_data` replaced with `data`
+    * `summary` replaced with `note`
+    * only `PASSED, FAILED, INFO, NEEDS_INSPECTION` are now valid `outcome` values
+    * `groups` is a list of `Group` uuids which the `Result` is part of
+    * When submitting new `Result`, `Testcase` and `Group` \[`resource`\] can be represented either by the unique identifier \[`uid`\]
+      (`Testcase.name`, `Group.uuid`), or by `object` containing the `uid`, and any other applicable `resource`'s attributes
+        * `resource` is identified by `uid` and:
+            * exists -> `resource` is linked to the `Result`
+            * does _not_ exist -> `resource` is created. Other attributes are set to default values
+        * `resource` is identified by `object` and:
+            * exists -> relevant attributes of the `resource` are updated to the provided values
+            * does _not_ exist -> `resource` is created, relevant attributes are set to the provided values
+* Changes in the `Testcase` object
+    * `ref_url` instead of `url`
+* Changes in querying:
+    * `*` (star) used as a wildcard instead of `%` (percent sign) in the `like:` filters
+    * Result
+        * added `testcases` keyword to filter by `Testcase.name`
+            * `like` filter allowed
+            * multiple values can be provided, separate by commas to get `or` filter based on all the values provided: `...&testcases=name1,name2`
+    * Group
+        * `like` filter for `description`
+* `_auth` placeholder for the Authorization/Authenticaion data in the Request queries; Ignored at the moment
+
+
+# Results [/results]
+
+`Result` is the most common entry in the database. We try to keep ResultsDB pretty "stupid" and only enforce the minimal common subset of attributes on
+the `Result` object. For example, when creating a new `Result`, only `outcome` and `testcase` parameters are required. Also, no specific meaning is really
+assigned to any of the (other) parameters.
+
+The other common attributes are `note`, to provide a short digest of the testrun's details, and `ref_url` which usually points to log or artifacts.
+
+Should you need to store additional data use the `data` keyval store. The stored data can then be used to filter `Results` searches.
+For example in Taskotron, `item` and `type` are used to represent "what was tested", where `type` could be `koji_build`, `bodhi_update`, `compose`, `docker_image` ...
+and `item` is then the (reasonable) identifier of said "item under test".
+
+We advise agaings using `_expand`, `_auth`, `_fields`, `_sort` and `_distinct_on` as key names - although ResultsDB will store and return the data, these keys might not be
+query-able for searching the `Results` collection, as these are reserved for the future API functionalities.
+
+Through all the `Result` instances, there is a `href` attribute, that represents a link to self.
+
++ Attributes (Result GET)
+
+
+## Retrieve a Result [GET /results/{id}]
+
+Retrieve a single `Result` based on the `id`.
+
++ Request .../results/7484989
+    + Parameters
+        + id: 7484989
+
++ Response 200 (application/json)
+
+        {
+            "id": 7484989,
+            "outcome": "PASSED",
+            "testcase": {
+                "name": "dist.rpmlint",
+                "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+                "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+            },
+            "note": "0 errors, 30 warnings",
+            "ref_url": "https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+            "submit_time": "2016-08-15T13:29:06",
+            "groups": ["27f94e36-62ec-11e6-83fd-525400d7d6a4"],
+            "data": {
+                "item": ["koschei-1.7.2-1.fc24"],
+                "type": ["koji_build"],
+                "arch": ["x86_64","noarch"]
+            },
+            "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results/7484989"
+        }
+
++ Response 404 (application/json)
+
+        {
+            "message":"Result not found"
+        }
+
+
+## Browse the Results collection [GET /results{?page,limit,outcome,testcases,groups,since,keyval}]
+
+Collection of all the Results. Results are returned in paginated format, and references to the next and previous page (if applicable) are
+given as a part of the reponse.
+
+The search can be filtered by time, or the `outcome`, or any of the key-values in the `data` store.
+By default, the `data` values are matched for equality, but `like` filter is available to allow for wildcard searches.
+
+Examples are provided in the Parameters section of the documentation.
+
++ Parameters
+    + page: 8 (number, optional)
+        + Default: 0
+    + limit: 20 (number, optional)
+        + Default: 20
+    + outcome: PASSED (enum, optional)
+        Multiple values can be provided, separate by coma to get `or` filter based on all the values provided: `...&outcome=PASSED,FAILED`
+        + Members
+            + PASSED
+            + FAILED
+            + INFO
+            + NEEDS_INSPECTION
+    + testcases: dist.rpmlint (string, optional)
+        - Multiple values can be provided, separate by coma to get `or` filter based on all the values provided: `...&testcases=dist.rpmlint,dist.depcheck`
+        - `like` filter with `*` as wildcard: `...&testcases:like=dist.*`
+    + groups: `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional)
+        - Multiple values can be provided, separate by commas to get `or` filter based on all the values provided: `...&groups=uuid1,uuid2`
+    + since: `2016-08-15T13:00:00` (string)
+        Date (or datetime) in ISO8601 format.
+        To specify range, separate start and end date(time) by comma: `...&since=2016-08-14,2016-08-15T13:42:57`
+    + keyval (string)
+        - Any key-value pair in `Result.data`. Replace `keyval` with the key's name: `...&item=koschei-1.7.2-1.fc24`
+        - Multiple values can be provided, separate by commas to get `or` filter based on all the values provided: `...&arch=x86_64,noarch`
+        - `like` filter with `*` as wildcards: `...&item:like=koschei*fc24*`
+        - Multiple key-value pairs provide `and` filter, e.g. to search for all `Results` with `item` like `koschei*fc24*` and `arch` being either `noarch` or `x86_64`: `...&item:like=koschei*fc24*&arch=noarch`
+
++ Request .../results?item:like=koschei*fc24*&outcome=PASSED,FAILED&since=2016-08-15T13:00:00,2016-08-15T13:30:00
+    + Parameters
+        + `item:like`: koschei*fc24*
+        + outcome: PASSED,FAILED
+        + since: 2016-08-15T13:00:00
+
++ Response 200 (application/json)
+
+        {
+            "next":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results?item:like=koschei*fc24*&outcome=PASSED,FAILED&since=2016-08-15T13:00:00,2016-08-15T13:30:00&page=1",
+            "prev":null,
+            "data":[
+                {
+                    "id":7484989,
+                    "outcome":"PASSED",
+                    "testcase":{
+                        "name":"dist.rpmlint",
+                        "ref_url":"https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+                        "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+                    },
+                    "groups":["27f94e36-62ec-11e6-83fd-525400d7d6a4"],
+                    "note":"0 errors, 30 warnings",
+                    "submit_time":"2016-08-15T13:29:06",
+                    "ref_url":"https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+                    "data":{
+                        "item":["koschei-1.7.2-1.fc24"],
+                        "type":["koji_build"],
+                        "arch":["x86_64","noarch"]
+                    },
+                    "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results/7484989"
+                }
+            ]
+        }
+
+
+## Get a list of latest Results for a specified filter [GET /results/latest{?keyval,testcases,groups,since,_distinct_on}]
+
+Especially with automation in mind, a simpe query to get the latest `Results` of all the `Testcases` based on a filter
+makes a lot of sense. For example Koji could be interested in data like "All current results for the `koji_build` `koschei-1.7.2-1.fc24`", without
+the need to browse the whole Results collection.
+
+This endpoint does just that - takes filter parameters, and returns the most recent result for all the relevant `Testcases`.
+Only `Testcases` with at least one `Result` that meet the filter are present - e.g. if ResultsDB contained `dist.rpmlint` and `dist.rpmgrill`
+`Testcases`, but there was only a `dist.rpmlint` `Result` for the `koschei-1.7.2-1.fc24` `koji_build`, just `dist.rpmlint`'s `Result` would be returned.
+
+An additional available parameter is `_distinct_on`, if specified allows the user to group by additional fields (example: `scenario`).
+
++ Parameters
+    + keyval (string)
+        - Any key-value pair in `Result.data`. Replace `keyval` with the key's name: `...&item=koschei-1.7.2-1.fc24`
+        - Multiple values can be provided, separate by commas to get `or` filter based on all the values provided: `...&arch=x86_64,noarch`
+        - `like` filter with `*` as wildcards: `...&item:like=koschei*fc24*`
+        - Multiple key-value pairs provide `and` filter, e.g. to search for all `Results` with `item` like `koschei*fc24*` and `arch` being either `noarch` or `x86_64`: `...&item:like=koschei*fc24*&arch=noarch`
+    + testcases (string, optional)
+        - Use to narrow down `Testcases` of interest. By default, all `Testcases` are searched for `Results`
+        - Multiple values can be provided, separate by comma to get `or` filter based on all the values provided: `...&testcases=dist.rpmlint,dist.depcheck`
+        - `like` filter with `*` as wildcards: `...&testcases:like=dist.*`
+    + groups: `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional)
+        - Multiple values can be provided, separate by commas to get `or` filter based on all the values provided: `...&groups=uuid1,uuid2`
+    + since: `2016-08-15T13:00:00` (string)
+        Date (or datetime) in ISO8601 format.
+        To specify range, separate start and end date(time) by comma: `...&since=2016-08-14,2016-08-15T13:42:57`
+    + _distinct_on: `scenario` (string, optional)
+        - The value can be any `key` in `Result.data`.  Example: `...&_distinct_on=scenario`
+        - Multiple values can be provided, separate by comma. Example: `...&_distinct_on=scenario,item`
+
++ Request `.../results/latest?item=koschei-1.7.2-1.fc24&type=koji_build`
+    + Parameters
+        + item: koschei-1.7.2-1.fc24
+        + type: koji_build
+
++ Response 200 (application/json)
+
+        {
+            "data":[
+                {
+                    "id":7484989,
+                    "outcome":"PASSED",
+                    "testcase":{
+                        "name":"dist.rpmlint",
+                        "ref_url":"https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+                        "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+                    },
+                    "groups":["27f94e36-62ec-11e6-83fd-525400d7d6a4"],
+                    "note":"0 errors, 30 warnings",
+                    "submit_time":"2016-08-15T13:29:06",
+                    "ref_url":"https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+                    "data":{
+                        "item":["koschei-1.7.2-1.fc24"],
+                        "type":["koji_build"],
+                        "arch":["x86_64","noarch"]
+                    },
+                    "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results/7484989"
+                }
+            ]
+        }
+
+## Create new Result [POST /results]
+
+To create new `Result`, simply provide a JSON object containing the `outcome` and `testcase` fields.
+Should you want to store more information, you can make use of `groups`, `note`, `ref_url` and `data` (the key-value store).
+
+When a new `Result` is created, it is assigned an unique `id` and `submit_time` (UTC time of the `Result` submission, unless it is overridden in the request) by the API.
+
++ Attributes (Result POST)
+
++ Request Using just the testcase/group identifiers (application/json)
+
+        {
+            "outcome":"PASSED",
+            "testcase":"dist.rpmlint",
+            "groups":["27f94e36-62ec-11e6-83fd-525400d7d6a4"],
+            "note":"0 errors, 30 warnings",
+            "data":{
+                "item":"koschei-1.7.2-1.fc24",
+                "type":"koji_build",
+                "arch":["x86_64","noarch"]
+            },
+            "ref_url":"https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+            "_auth": null
+        }
+
++ Request Using the whole testcase/group objects (application/json)
+
+        {
+            "outcome":"PASSED",
+            "testcase":{"name":"dist.rpmlint", "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues"},
+            "groups":[{"uuid":"27f94e36-62ec-11e6-83fd-525400d7d6a4", "description":"Taskotron job on koji_build koschei-1.7.2-1.fc24"}],
+            "note":"0 errors, 30 warnings",
+            "data":{
+                "item":"koschei-1.7.2-1.fc24",
+                "type":"koji_build",
+                "arch":["x86_64","noarch"]
+            },
+            "ref_url":"https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+            "_auth": null
+        }
+
++ Response 201 (application/json)
+
+        {
+            "id":7484989,
+            "outcome":"PASSED",
+            "testcase":{
+                "name":"dist.rpmlint",
+                "ref_url":"https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+                "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+            },
+            "groups":["27f94e36-62ec-11e6-83fd-525400d7d6a4"],
+            "note":"0 errors, 30 warnings",
+            "submit_time":"2016-08-15T13:29:06",
+            "ref_url":"https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log",
+            "data":{
+                "item":["koschei-1.7.2-1.fc24"],
+                "type":["koji_build"],
+                "arch":["x86_64","noarch"]
+            },
+            "href":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results/7484989"
+        }
+
++ Response 400 (application/json)
+
+    When any of the required attributes is missing.
+
+    + Body
+
+            {
+                "message": "Missing data"
+            }
+
+
+# Result Groups [/groups]
+
+As not all `Results` are necessarily standalone, the `Group` resource can be used to organize them into any number of groups.
+
+Each group is identified by `uuid`, and when you create a new group, you can either provide your own UUID ([RFC4122](https://tools.ietf.org/html/rfc4122),
+[Wiki](https://en.wikipedia.org/wiki/Universally_unique_identifier)), or let ResultsDB create one for you.
+
+Groups can be either created in advance, using this resource's methods, or on the fly during the `Result` submission. If you use the latter,
+but still want to group several `Results` into a group, we suggest using UUID
+[Version 3](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_3_.28MD5_hash_.26_namespace.29) or
+[Version 5](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_5_.28SHA-1_hash_.26_namespace.29),
+and building your own namespaces in order to identify the groups with a predictable UUID.
+
+On top of `uuid`, the `Group` can also contain `description` to explain the `Group`'s purpose, and `ref_url` to point to outside resource
+like execution state, or a related documentation.
+
+
++ Attributes (Group GET)
+
+
+## Retrieve a Group [GET /groups/{uuid}]
+
+Retrieve a single `Group` based on the `uuid`.
+
++ Request .../groups/27f94e36-62ec-11e6-83fd-525400d7d6a4
+    + Parameters
+        + uuid: 27f94e36-62ec-11e6-83fd-525400d7d6a4
+
++ Response 200 (application/json)
+
+        {
+            "uuid": "27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "description": "Taskotron job on koji_build koschei-1.7.2-1.fc24",
+            "ref_url": "https://taskotron-dev.fedoraproject.org/execdb/jobs/27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "results": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results?group=27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "results_count": 1,
+            "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/groups/27f94e36-62ec-11e6-83fd-525400d7d6a4"
+        }
+
+
++ Response 404 (application/json)
+
+        {
+            "message":"Group not found"
+        }
+
+
+## Browse the Group collection [GET /groups{?page,limit,description,uuid}]
+
+Collection of all the `Groups`.
+`Groups` are returned in paginated format, and references to the next and previous page (if applicable) are given as a part of the reponse.
+
++ Parameters
+    + page: 8 (number, optional)
+        + Default: 0
+    + limit: 20 (number, optional)
+        + Default: 20
+    + description: `Taskotron job` (string, optional)
+        - Multiple values can be provided, separate by coma to get `or` filter based on all the values provided: `...&description=Taskotron job,OpenQA job`
+        - `like` filter with `*` as wildcards: `...&description:like=Taskotron*`
+    + uuid: `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional)
+        - Multiple values can be provided, separate by coma to get `or` filter based on all the values provided: `...&uuid=27f94e36-62ec-11e6-83fd-525400d7d6a4,...`
+
++ Response 200 (application/json)
+
+        {
+            "next":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/groups?page=1",
+            "prev":null,
+            "data":[
+                {
+                    "uuid": "27f94e36-62ec-11e6-83fd-525400d7d6a4",
+                    "description": "Taskotron job on koji_build koschei-1.7.2-1.fc24",
+                    "ref_url": "https://taskotron-dev.fedoraproject.org/execdb/jobs/27f94e36-62ec-11e6-83fd-525400d7d6a4",
+                    "results": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results?group=27f94e36-62ec-11e6-83fd-525400d7d6a4",
+                    "results_count": 1,
+                    "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/groups/27f94e36-62ec-11e6-83fd-525400d7d6a4"
+                }
+            ]
+        }
+
+
+## Create new Group [POST /groups]
+
+To create new `Group`, you can simply post an empty JSON object, and new `Group` with an unique UUID
+[Version 1](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_.28date-time_.26_MAC_address.29)
+will be created. Should you want to store more information, you can make use of `description` and `ref_url`.
+
+You can also provide your own `uuid`, in which case we strongly suggest UUID
+[Version 3](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_3_.28MD5_hash_.26_namespace.29) or
+[Version 5](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_5_.28SHA-1_hash_.26_namespace.29),
+and building your own namespaces in order to identify the groups with a predictable, but non-conflicting UUID.
+
+Note that when an `uuid` already exists, new entry will not be created, but rather the old one will get updated with
+the new `description` or `ref_url`, if set in the JSON data.
+
++ Attributes (Group POST)
+
++ Request (application/json)
+
+        {
+            "uuid": "27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "description": "Taskotron job on koji_build koschei-1.7.2-1.fc24",
+            "ref_url": "https://taskotron-dev.fedoraproject.org/execdb/jobs/27f94e36-62ec-11e6-83fd-525400d7d6a4",
+        }
+
++ Response 201 (application/json)
+
+        {
+            "uuid": "27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "description": "Taskotron job on koji_build koschei-1.7.2-1.fc24",
+            "ref_url": "https://taskotron-dev.fedoraproject.org/execdb/jobs/27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "results": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results?group=27f94e36-62ec-11e6-83fd-525400d7d6a4",
+            "results_count": 0,
+            "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/groups/27f94e36-62ec-11e6-83fd-525400d7d6a4"
+        }
+
+
+# Testcases [/testcases]
+
+Each `Result` has to have one `Testcase` assigned.
+
+In ResultsDB, `Testcases` can be organized into namespaces using a separator in the `Testcase.name` attribute. Although you can use anything
+as a sepparator, we suggest `.` (dot) as it does not have to be URL-encoded, and is a fairly common separator for the usecase.
+
+ResultsDB is not (supposed to be) smart enough to assing any actual meaning to the `Testcase.name`, and thus can not decide on its own,
+what is a namespace, and what is a subcheck e.g. `dist.` is a namespace in Taskotron, but `dist.rpmgrill` is a checkname, which can then
+contain subchecks, that get represented as `dist.rpmgrill.subcheck_foobar`. It is always the consumer's responsibility to make use of
+the (possible) namespacing in the way correct for the specific problem.
+
+That said, ResultsDB is able to perform namespace searches, and possibly other operations that are not implemented yet (e.g. auth-based
+ability to submit `Results` only for a limited subset of namespaces).
+
+Each `Testcase` is identified by its `name` attribute, which is unique in the ResultsDB. `ref_url` can be used to point to an outside
+resource like documentation, or a list of well-known issues for the `Testcase`
+
++ Attributes (Testcase GET)
+
+
+## Retrieve a Testcase [GET /testcases/{name}]
+
+Retrieve a single `Testcase` based on the `name`.
+
+
++ Request .../testcases/dist.rpmlint
+    + Parameters
+        + name: dist.rpmlint
+
++ Response 200 (application/json)
+
+        {
+            "name": "dist.rpmlint",
+            "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+            "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+        }
+
++ Response 404 (application/json)
+
+        {
+            "message":"Testcase not found"
+        }
+
+
+## Browse the Testcase collection [GET /testcases{?page,limit,name}]
+
+Collection of all the `Testcases`.
+`Testcases` are returned in paginated format, and references to the next and previous page (if applicable) are given as a part of the reponse.
+
++ Parameters
+    + page: 8 (number, optional)
+        + Default: 0
+    + limit: 20 (number, optional)
+        + Default: 20
+    + name: `dist.rpmlint` (string, optional)
+        - Multiple values can be provided, separate by coma to get `or` filter based on all the values provided: `...&name=dist.rpmlint,dist.rpmgrill`
+        - `like` filter with `*` as wildcards: `...&name:like=dist.rpmgrill.*`
+
++ Request .../testcases?name:like=dist.rpmlint.*
+    + Parameters
+        + `name:like`: dist.rpmlint.*
+
++ Response 200 (application/json)
+
+        {
+            "next":"https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/name:like=dist.rpmlint.*&page=1",
+            "prev":null,
+            "data":[
+                {
+                    "name": "dist.rpmlint",
+                    "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+                    "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+                }
+            ]
+        }
+
+
+## Create new Testcase [POST /testcases]
+
+To create new `Testcase`, post a JSON object containing the `name` parameter, and possibly also the `ref_url`.
+
+Note that when a `Testcase` with the `name` already exists, new entry will not be created, but rather the old one will
+get updated with the new `ref_url`, if set in the JSON data.
+
++ Attributes (Testcase POST)
+
++ Request (application/json)
+
+        {
+            "name": "dist.rpmlint",
+            "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+        }
+
++ Response 201 (application/json)
+
+        {
+            "name": "dist.rpmlint",
+            "ref_url": "https://fedoraproject.org/wiki/Common_Rpmlint_issues",
+            "href": "https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint"
+        }
+
+
+# Data Structures
+
+## OUTCOMES (enum)
+- PASSED
+- FAILED
+- INFO - represents a "soft pass" - use to treat as `"PASSED"` by automation/gating, and flag for human review
+- NEEDS_INSPECTION - use to treat as `"FAILED"` by automation/gating, and flag for human review
+
+## Result GET (object)
+- id: 7484989 (number, required) - Unique identifier. Assigned by API at the moment of creation.
+- testcase (required, Testcase GET) - The `Testcase` associated with the result.
+- outcome (OUTCOMES, required) - Represents the outcome of the testing.
+- note: `0 errors, 30 warnings` (string, optional, nullable) - Should be used as a _short_ summary of important information about the result. Detailed hints/logs should be accessible at the `ref_url` URL.
+- `ref_url`: `https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log` (string, optional) - Use as a pointer to logs/artifacts/detailed information about the result.
+- submit_time: `2016-08-15T13:29:06` (string) - UTC time of the result creation in ISO8601 format.
+- groups (array) - List of `Groups`'s UUIDs the result is part of.
+    - `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string)
+- data (object) - Any number of key-value pairs. Used to store any additional information. In Taskotron `item` and `type` are the most common keys used to represent "what was tested".
+    - *key* (array[string], optional)
+- `href`: `https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results/7484989` (string) - Reference to self.
+
+## Result POST (object)
+- outcome (OUTCOMES, required)
+- testcase (enum, required)
+    `Testcase` can be represented either by `testcase.name`, or by `object` containing the `name`, and any other applicable attributes.
+    * When identified by `name` and:
+        * exists ->  is linked to the `Result`
+        * does _not_ exist ->  is created. Other attributes are set to default values
+    * When identified by `object` and:
+        * exists -> is linked to the `Result`, relevant attributes are updated to the provided values
+        * does _not_ exist -> is created, relevant attributes are set to the provided values
+    - Members
+        - (Testcase POST data)
+        - `dist.rpmlint` (string) - `testcase.name` - Unique identifier. Represents namespacing, using `.` (dot) as a namespace separator
+- groups (array, optional, nullable)
+    `Group`s can be represented either by `uuid`, or by `object` containing the `uuid`, and any other applicable attributes.
+    * When identified by `uuid` and:
+        * exists ->  is linked to the `Group`
+        * does _not_ exist ->  is created. Other attributes are set to default values
+    * When identified by `object` and:
+        * exists -> is linked to the `Group`, relevant attributes are updated to the provided values
+        * does _not_ exist -> is created, relevant attributes are set to the provided values
+    - Items
+        - (Group POST data) - foobar
+        - `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string) - `Group.uuid` - Unique identifier
+- note: `0 errors, 30 warnings` (string, optional, nullable) - Should be used as a _short_ summary of important information about the result. Detailed hints/logs should be accessible at the `ref_url` URL.
+- `ref_url`: `https://taskotron-dev.fedoraproject.org/artifacts/all/27f94e36-62ec-11e6-83fd-525400d7d6a4/task_output/koschei-1.7.2-1.fc24.log` (string, optional, nullable) - Use as a pointer to logs/artifacts/detailed information about the result.
+- data (object, optional, nullable) - Any number of key-value pairs used to store any additional information. Note that colon `:` can not be a part of key's name, since it is used in the API as a filter separator (i.e. `:like`), and the key would be inaccessible.
+    - *key* (enum)
+        - `foo` (string) - Single value
+        - `foo`, `bar` (array[string]) - List of values
+- `submit_time` (string/number, optional, nullable): UTC time of the result creation in ISO8601 format (YYYY-MM-DDTHH:MM:SS.ffffff) or a number of milliseconds since the Epoch. Defaults to the time of the `Result` submission.
+- _auth (object, nullable, optional) - Placeholder for the future implemantation of Authentication/Authorization
+
+
+## Group POST data (object)
+`Group` object containing the relevant attributes
+### Properties
+- uuid: `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional) - UUID in one of the RFC4122 formats
+- description: `Taskotron job on koji_build koschei-1.7.2-1.fc24` (string, optional, nullable) - Short description of the group - intended to be consumed by humans.
+- `ref_url`: `https://taskotron-dev.fedoraproject.org/execdb/jobs/27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional, nullable) - URL pointing to logs/execution status/...
+
+## Group POST (Group POST data)
+- uuid: `27f94e36-62ec-11e6-83fd-525400d7d6a4` (string, optional) - If not provided, ResultsDB will assign an UUID1 value to it
+- _auth (nullable, optional) - Placeholder for the future implemantation of Authentication/Authorization
+
+## Group GET (Group POST data)
+- results: `https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/results?group=27f94e36-62ec-11e6-83fd-525400d7d6a4` (string) - URL to retrieve results in the `Group` via the `Result` resource
+- `results_count`: 1 (number) - Amount of `Results` in the `Group`
+- `href`: `https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/groups/27f94e36-62ec-11e6-83fd-525400d7d6a4` (string) - Reference to self.
+
+
+## Testcase POST data (object)
+`Testcase` object containing the relevant attributes
+### Properties
+- name: `dist.rpmlint` (string, required) - Unique identifier. Represents namespacing, using dot `.` as a namespace separator.
+- `ref_url`: `https://fedoraproject.org/wiki/Common_Rpmlint_issues` (string, optional, nullable) - URL pointing to the documentation or other reference material.
+
+## Testcase POST (Testcase POST data)
+- _auth (nullable, optional) - Placeholder for the future implemantation of Authentication/Authorization.
+
+## Testcase GET (Testcase POST data)
+- `href`: `https://taskotron-dev.fedoraproject.org/resultsdb_api/api/v2.0/testcases/dist.rpmlint` (string) - Reference to self.

data/Dockerfile

@@ -0,0 +1,117 @@
+FROM quay.io/fedora/python-313:20250716@sha256:3d229a9b58a9f5245d5696d7f817309ecfb2da2d92cc11cdad5a25308164421b AS builder
+
+# builder should use root to install/create all files
+USER root
+
+# hadolint ignore=DL3033,DL3041,DL4006,SC2039,SC3040
+RUN set -exo pipefail \
+    && mkdir -p /mnt/rootfs \
+    # install runtime dependencies
+    && dnf install -y \
+        --installroot=/mnt/rootfs \
+        --use-host-config \
+        --setopt install_weak_deps=false \
+        --nodocs \
+        --disablerepo=* \
+        --enablerepo=fedora,updates \
+        krb5-libs \
+        mod_ssl \
+        openldap \
+        python3 \
+        httpd-core \
+        python3-mod_wsgi \
+    && dnf --installroot=/mnt/rootfs clean all \
+    && ln -s mod_wsgi-express-3 /mnt/rootfs/usr/bin/mod_wsgi-express \
+    # https://python-poetry.org/docs/master/#installing-with-the-official-installer
+    && curl -sSL --proto "=https" https://install.python-poetry.org | python3 - \
+    && python3 -m venv /venv
+
+ENV \
+    PIP_DEFAULT_TIMEOUT=100 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONFAULTHANDLER=1 \
+    PYTHONHASHSEED=random \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /build
+
+# Copy only specific files to avoid accidentally including any generated files
+# or secrets.
+COPY resultsdb ./resultsdb
+COPY conf ./conf
+COPY \
+    pyproject.toml \
+    poetry.lock \
+    README.md \
+    alembic.ini \
+    entrypoint.sh \
+    ./
+
+# hadolint ignore=SC1091
+RUN set -ex \
+    && export PATH=/root/.local/bin:"$PATH" \
+    && . /venv/bin/activate \
+    && poetry build --format=wheel \
+    && version=$(poetry version --short) \
+    && pip install --no-cache-dir dist/resultsdb-"$version"-py3*.whl \
+    && deactivate \
+    && mv /venv /mnt/rootfs \
+    && mkdir -p /mnt/rootfs/app \
+    && cp -v entrypoint.sh /mnt/rootfs/app
+
+# fix apache config for container use
+RUN sed -i 's#^WSGISocketPrefix .*#WSGISocketPrefix /tmp/wsgi#' conf/resultsdb.conf \
+    # install configuration
+    && install -d /mnt/rootfs/usr/share/resultsdb/conf \
+    && install -p -m 0644 conf/resultsdb.conf /mnt/rootfs/usr/share/resultsdb/conf/ \
+    && install -p -m 0644 conf/resultsdb.wsgi /mnt/rootfs/usr/share/resultsdb/ \
+    && install -d /mnt/rootfs/etc/resultsdb \
+    && install -p -m 0644 conf/resultsdb.conf /mnt/rootfs/etc/httpd/conf.d/ \
+    # install alembic configuration and migrations
+    && install -p -m 0644 alembic.ini /mnt/rootfs/usr/share/resultsdb/alembic.ini \
+    && cp -a resultsdb/alembic /mnt/rootfs/usr/share/resultsdb/alembic \
+    && chmod -R 0755 /mnt/rootfs/usr/share/resultsdb/alembic
+
+# This is just to satisfy linters
+USER 1001
+
+# --- Final image
+FROM scratch
+ARG GITHUB_SHA
+ARG EXPIRES_AFTER
+LABEL \
+    name="ResultsDB application" \
+    vendor="ResultsDB developers" \
+    license="GPLv2+" \
+    description="ResultsDB is a results store engine for, but not limited to, Fedora QA tools." \
+    usage="https://pagure.io/taskotron/resultsdb/blob/develop/f/openshift/README.md" \
+    url="https://github.com/release-engineering/resultsdb" \
+    vcs-type="git" \
+    vcs-ref=$GITHUB_SHA \
+    io.k8s.display-name="ResultsDB" \
+    quay.expires-after=$EXPIRES_AFTER
+
+ENV \
+    PYTHONFAULTHANDLER=1 \
+    PYTHONHASHSEED=random \
+    PYTHONUNBUFFERED=1 \
+    WEB_CONCURRENCY=8
+
+COPY --from=builder /mnt/rootfs/ /
+COPY --from=builder \
+    /etc/yum.repos.d/fedora.repo \
+    /etc/yum.repos.d/fedora-updates.repo \
+    /etc/yum.repos.d/
+WORKDIR /app
+
+USER 1001
+EXPOSE 5001
+
+# Validate virtual environment
+RUN /app/entrypoint.sh python -c 'import resultsdb' \
+    && mod_wsgi-express module-config \
+    && /app/entrypoint.sh resultsdb --help
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+USER 1001:0

data/LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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 General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

data/alembic.ini

@@ -0,0 +1,68 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = resultsdb/alembic
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; this defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path
+# version_locations = %(here)s/bar %(here)s/bat alembic/versions
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

data/conf/fedora-messaging-example.toml

@@ -0,0 +1,18 @@
+# A sample configuration for fedora-messaging. This file is in the TOML format.
+# For complete details on all configuration options, see the documentation.
+
+amqp_url = "amqp://"
+
+publish_exchange = "amq.topic"
+
+# The topic_prefix configuration value will add a prefix to the topics of every sent message.
+# This is used for migrating from fedmsg, and should not be used afterwards.
+topic_prefix = ""
+
+[tls]
+ca_cert = "/etc/pki/tls/certs/ca-bundle.crt"
+keyfile = "/my/client/key.pem"
+certfile = "/my/client/cert.pem"
+
+[client_properties]
+app = "ResultsDB"

data/conf/oauth2_client_secrets.json.example

@@ -0,0 +1,11 @@
+{"web": {
+        "client_id": "resultsdbdev",
+        "client_secret": "uvwFVN7SNgmNCQVJTR9QdrkMginl0RM4",
+        "auth_uri": "https://iddev.fedorainfracloud.org/openidc/Authorization",
+        "token_uri": "https://iddev.fedorainfracloud.org/openidc/Token",
+        "userinfo_uri": "https://iddev.fedorainfracloud.org/openidc/UserInfo",
+        "redirect_uris": ["https://resultsdb.example.com/oidc_callback"],
+        "issuer": "https://iddev.fedorainfracloud.org/openidc/",
+        "token_introspection_uri": "https://iddev.fedorainfracloud.org/openidc/TokenInfo"
+      }
+}

data/conf/resultsdb.conf

@@ -0,0 +1,20 @@
+WSGIDaemonProcess resultsdb user=apache group=apache threads=5
+WSGIScriptAlias /resultsdb /usr/share/resultsdb/resultsdb.wsgi
+WSGISocketPrefix run/wsgi
+
+<Directory /usr/share/resultsdb>
+    WSGIProcessGroup resultsdb
+    WSGIApplicationGroup %{GLOBAL}
+    WSGIScriptReloading On
+    Order deny,allow
+    Allow from all
+    Require all granted
+</Directory>
+
+#Alias /resultsdb/static /var/www/resultsdb/resultsdb/static
+
+#<Directory /var/www/resultsdb/resultsdb/static>
+#Order allow,deny
+#Allow from all
+#Require all granted
+#</Directory>

data/conf/resultsdb.wsgi

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-2.0+
+from resultsdb import create_app
+
+application = create_app()

data/conf/settings.py.example

@@ -0,0 +1,95 @@
+# Copy this file to `conf/settings.py` to put it into effect. It overrides the values defined
+# in `resultsdb/config.py`.
+
+# ================== General ===================
+
+DEBUG=False
+PRODUCTION=True
+SECRET_KEY = 'replace-me-with-something-random'
+
+HOST = '0.0.0.0'
+PORT = 5001
+
+
+SQLALCHEMY_DATABASE_URI = 'sqlite:////var/tmp/resultsdb_db.sqlite'
+#SQLALCHEMY_DATABASE_URI = 'postgresql+psycopg2://dbuser:dbpassword@dbhost:dbport/dbname'
+SHOW_DB_URI = False
+
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'loggers': {
+        'resultsdb': {
+            'level': 'INFO',
+        },
+        'dogpile': {
+            'level': 'WARNING',
+        },
+    },
+    'handlers': {
+        'console': {
+            'formatter': 'bare',
+            'class': 'logging.StreamHandler',
+            'stream': 'ext://sys.stdout',
+            'level': 'INFO',
+        },
+    },
+    'formatters': {
+        'bare': {
+            'format': '[%(asctime)s] [%(process)d] [%(levelname)s] %(name)s: %(message)s',
+            'datefmt': '%Y-%m-%d %H:%M:%S',
+        }
+    },
+    'root': {
+        'level': 'WARNING',
+        'handlers': ['console'],
+    },
+}
+
+# Extend the list of allowed outcomes.
+ADDITIONAL_RESULT_OUTCOMES = []
+
+# Fedmenu configuration
+FEDMENU_URL = 'https://apps.fedoraproject.org/fedmenu'
+FEDMENU_DATA_URL = 'https://apps.fedoraproject.org/js/data.js'
+
+# ================== Authentication ===================
+
+# Supported values: "oidc"
+AUTH_MODULE = None
+
+# OIDC Configuration
+import os
+OIDC_CLIENT_SECRETS = os.getcwd() + '/conf/oauth2_client_secrets.json'
+OIDC_RESOURCE_SERVER_ONLY = True
+OIDC_USERNAME_FIELD = 'uid'
+
+
+# ================== Messaging ===================
+
+# Set this to True or False to enable publishing to a message bus
+MESSAGE_BUS_PUBLISH = False
+# Name of the message bus plugin to use goes here.  'fedmsg' is installed by
+# default, but you could create your own.
+# Supported values: 'dummy', 'stomp', 'fedmsg'
+MESSAGE_BUS_PLUGIN = 'fedmsg'
+MESSAGE_BUS_KWARGS = {'modname': 'resultsdb'}
+
+## Alternatively, you could use the 'stomp' messaging plugin.
+#MESSAGE_BUS_PLUGIN = 'stomp'
+#MESSAGE_BUS_KWARGS = {
+#    'destination': '/topic/VirtualTopic.eng.resultsdb.result.new',
+#    'connection': {
+#        'host_and_ports': [
+#            ('broker01', 61612),
+#            ('broker02', 61612),
+#        ],
+#        'use_ssl': True,
+#        'ssl_key_file': '/path/to/key/file',
+#        'ssl_cert_file': '/path/to/cert/file',
+#        'ssl_ca_certs': '/path/to/ca/certs',
+#    },
+#}
+
+# Publish Taskotron-compatible fedmsgs on the 'taskotron' topic
+MESSAGE_BUS_PUBLISH_TASKOTRON = False

data/entrypoint.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# ENTRYPOINT for the container.
+# Activates virtualenv before running any commands.
+set -e
+
+# shellcheck disable=SC1091
+. /venv/bin/activate
+
+if [[ $# == 0 ]]; then
+    exec mod_wsgi-express \
+        start-server \
+        /usr/share/resultsdb/resultsdb.wsgi \
+        --user=apache \
+        --group=apache \
+        --processes="${MOD_WSGI_PROCESSES:-1}" \
+        --threads="${MOD_WSGI_THREADS:-5}" \
+        --port="${MOD_WSGI_PORT:-5001}" \
+        --include-file=/etc/httpd/conf.d/resultsdb.conf \
+        --log-level="${MOD_WSGI_LOG_LEVEL:-info}" \
+        --log-to-terminal \
+        --access-log \
+        --startup-log
+else
+    exec "$@"
+fi

data/get-version.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# SPDX-License-Identifier: GPL-2.0+
+
+# Prints the current version based on the current git revision.
+
+set -e
+
+if [[ -n "$GITHUB_SHA" ]]; then
+    if [[ $GITHUB_REF =~ ^ref/tags/ ]]; then
+        echo "${GITHUB_REF#refs/tags/}"
+    else
+        last_version=$(poetry version --short)
+        echo "$last_version+git.${GITHUB_SHA:0:7}"
+    fi
+    exit
+fi
+
+if [ "$(git tag | wc -l)" -eq 0 ] ; then
+    # never been tagged since the project is just starting out
+    lastversion="0.0"
+    revbase=""
+else
+    lasttag="$(git describe --abbrev=0 HEAD)"
+    lastversion="$lasttag"
+    revbase="^$lasttag"
+fi
+if [ "$(git rev-list $revbase HEAD | wc -l)" -eq 0 ] ; then
+    # building a tag
+    version="$lastversion"
+else
+    # git builds count as a pre-release of the next version
+    version="$lastversion"
+    version="${version%%[a-z]*}" # strip non-numeric suffixes like "rc1"
+    # increment the last portion of the version
+    version="${version%.*}.$((${version##*.} + 1))"
+    commitcount=$(git rev-list $revbase HEAD | wc -l)
+    commitsha=$(git rev-parse --short HEAD)
+    version="${version}.dev${commitcount}+git.${commitsha}"
+fi
+
+echo $version

data/gunicorn.cfg

@@ -0,0 +1,5 @@
+import logging
+import sys
+
+gunicorn_logger = logging.getLogger('gunicorn.error')
+gunicorn_logger.addHandler(logging.StreamHandler(sys.stdout))

data/init_db.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e
+poetry run resultsdb init_alembic
+poetry run resultsdb init_db
+poetry run resultsdb mock_data

data/migration.sh

@@ -0,0 +1,8 @@
+git commit -am .
+docker stop pg_resultsdb;docker rm pg_resultsdb;docker run --name pg_resultsdb -e POSTGRES_USER=resultsdb -e POSTGRES_PASSWORD=fedora -p 5432:5432 -d postgres
+sleep 10
+git co 5dc67d8382dd0c0aaf5b9d74df4dd2c00585af4e; DEV=true bash init_db.sh; git co feature/v20
+DEV=true alembic upgrade 540dbe71fa91
+
+
+#DEV=true alembic upgrade head

data/openshift/resultsdb-test-template.yaml

@@ -0,0 +1,289 @@
+
+# Template to produce a new test environment in OpenShift. Uses OpenID Connect
+# against iddev.fedorainfracloud.org for authentication, and ephemeral storage
+# for Postgres data.
+#
+# To create an environment from the template, process and apply it:
+#   oc process -f openshift/resultsdb-test-template.yaml -p TEST_ID=123 | oc apply -f -
+# To clean up the environment, use a selector on the environment label:
+#   oc delete dc,deploy,pod,configmap,secret,svc,route -l environment=test-123
+
+---
+apiVersion: v1
+kind: Template
+metadata:
+  name: resultsdb-test-template
+parameters:
+- name: TEST_ID
+  displayName: Test id
+  description: Short unique identifier for this test run (e.g. Jenkins job number)
+  required: true
+- name: RESULTSDB_IMAGE
+  displayName: ResultsDB container image
+  description: Image to be used for ResultsDB deployement
+  value: 172.30.1.1:5000/myproject/resultsdb:latest
+  required: true
+- name: DATABASE_PASSWORD
+  displayName: Database password
+  generate: expression
+  from: "[\\w]{32}"
+- name: RESULTSDB_SECRET_KEY
+  displayName: Secret Key for ResultsDB
+  generate: expression
+  from: "[\\w]{32}"
+- name: RESULTSDB_ADDITIONAL_RESULT_OUTCOMES
+  displayName: Additional outcomes values.
+  value: "[]"
+objects:
+- apiVersion: v1
+  kind: Secret
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-secret"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  stringData:
+    database-password: "${DATABASE_PASSWORD}"
+- apiVersion: v1
+  kind: Secret
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-config"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  stringData:
+    settings.py: |-
+      SECRET_KEY = '${RESULTSDB_SECRET_KEY}'
+      SQLALCHEMY_DATABASE_URI = 'postgresql+psycopg2://resultsdb:${DATABASE_PASSWORD}@resultsdb-test-${TEST_ID}-database:5432/resultsdb'
+      FILE_LOGGING = False
+      LOGFILE = '/var/log/resultsdb/resultsdb.log'
+      SYSLOG_LOGGING = False
+      STREAM_LOGGING = True
+      RUN_HOST= '0.0.0.0'
+      RUN_PORT = 5001
+      MESSAGE_BUS_PUBLISH = False
+      MESSAGE_BUS_PLUGIN = 'fedmsg'
+      MESSAGE_BUS_KWARGS = {'modname': 'resultsdb'}
+      ADDITIONAL_RESULT_OUTCOMES = ${RESULTSDB_ADDITIONAL_RESULT_OUTCOMES}
+    # Credentials are resultsdb-updater:password
+    .htpasswd: |-
+      resultsdb-updater:$2y$05$yAlqAYWqfMoxAMrFgFMfpuQsDw.v5b4tuS8x43h6tcPP1gIXBRutq
+- apiVersion: v1
+  kind: ConfigMap
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-httpd-config"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  data:
+    resultsdb.conf: |-
+      <IfModule !auth_basic_module>
+        LoadModule auth_basic_module '${MOD_WSGI_MODULES_DIRECTORY}/mod_auth_basic.so'
+      </IfModule>
+      <IfModule !authn_file_module>
+        LoadModule authn_file_module '${MOD_WSGI_MODULES_DIRECTORY}/mod_authn_file.so'
+      </IfModule>
+      <IfModule !authz_user_module>
+        LoadModule authz_user_module '${MOD_WSGI_MODULES_DIRECTORY}/mod_authz_user.so'
+      </IfModule>
+
+      <Location "/">
+        AuthType Basic
+        AuthName "Authentication Required"
+        AuthBasicProvider file
+        AuthUserFile "/etc/resultsdb/.htpasswd"
+        <LimitExcept GET>
+          Require valid-user
+        </LimitExcept>
+      </Location>
+- apiVersion: v1
+  kind: Service
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-database"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  spec:
+    selector:
+      app: resultsdb
+      environment: "test-${TEST_ID}"
+      service: database
+    ports:
+    - name: postgresql
+      port: 5432
+      targetPort: 5432
+- apiVersion: v1
+  kind: DeploymentConfig
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-database"
+    labels:
+      environment: "test-${TEST_ID}"
+      service: database
+      app: resultsdb
+  spec:
+    replicas: 1
+    strategy:
+      type: Recreate
+    selector:
+      app: resultsdb
+      environment: "test-${TEST_ID}"
+      service: database
+    template:
+      metadata:
+        labels:
+          environment: "test-${TEST_ID}"
+          service: database
+          app: resultsdb
+      spec:
+        containers:
+        - name: postgresql
+          image: registry.access.redhat.com/rhscl/postgresql-95-rhel7:latest
+          imagePullPolicy: Always
+          ports:
+          - containerPort: 5432
+            protocol: TCP
+          resources:
+            limits:
+              memory: 512Mi
+              cpu: 0.4
+          readinessProbe:
+            timeoutSeconds: 1
+            initialDelaySeconds: 5
+            exec:
+              command: [ /bin/sh, -i, -c, "psql -h 127.0.0.1 -U $POSTGRESQL_USER -q -d $POSTGRESQL_DATABASE -c 'SELECT 1'" ]
+          livenessProbe:
+            timeoutSeconds: 1
+            initialDelaySeconds: 30
+            tcpSocket:
+              port: 5432
+          env:
+          - name: POSTGRESQL_USER
+            value: resultsdb
+          - name: POSTGRESQL_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                name: "resultsdb-test-${TEST_ID}-secret"
+                key: database-password
+          - name: POSTGRESQL_DATABASE
+            value: resultsdb
+    triggers:
+    - type: ConfigChange
+- apiVersion: v1
+  kind: Service
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-api"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  spec:
+    selector:
+      app: resultsdb
+      environment: "test-${TEST_ID}"
+      service: api
+    ports:
+    - name: api
+      port: 5001
+      targetPort: 5001
+- apiVersion: v1
+  kind: Route
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-api"
+    labels:
+      environment: "test-${TEST_ID}"
+      app: resultsdb
+  spec:
+    port:
+      targetPort: api
+    to:
+      kind: Service
+      name: "resultsdb-test-${TEST_ID}-api"
+    tls:
+      termination: edge
+      insecureEdgeTerminationPolicy: Redirect
+- apiVersion: v1
+  kind: DeploymentConfig
+  metadata:
+    name: "resultsdb-test-${TEST_ID}-api"
+    labels:
+      environment: "test-${TEST_ID}"
+      service: api
+      app: resultsdb
+  spec:
+    replicas: 2
+    selector:
+      app: resultsdb
+      environment: "test-${TEST_ID}"
+      service: api
+    strategy:
+      type: Rolling
+      rollingParams:
+        pre:
+          failurePolicy: Abort
+          execNewPod:
+            containerName: api
+            command:
+              - /bin/sh
+              - -i
+              - -c
+              - |
+                # try for 10 minutes (600 seconds)
+                e=$(( $(date +%s) + 600 ))
+                i=0
+                while [ $(date +%s) -lt $e ]; do
+                  echo 'TRY #'$((++i))
+                  if resultsdb init_db ; then
+                    exit 0
+                  fi
+                done
+                exit 1
+            volumes:
+            - config-volume
+            - httpd-config-volume
+    template:
+      metadata:
+        labels:
+          environment: "test-${TEST_ID}"
+          service: api
+          app: resultsdb
+      spec:
+        containers:
+        - name: api
+          image: "${RESULTSDB_IMAGE}"
+          imagePullPolicy: Always
+          ports:
+          - containerPort: 5001
+          volumeMounts:
+          - name: config-volume
+            mountPath: /etc/resultsdb
+            readOnly: true
+          - name: httpd-config-volume
+            mountPath: /etc/httpd/conf.d
+            readOnly: true
+          readinessProbe:
+            timeoutSeconds: 1
+            initialDelaySeconds: 5
+            httpGet:
+              path: /api/v2.0/
+              port: 5001
+          livenessProbe:
+            timeoutSeconds: 1
+            initialDelaySeconds: 30
+            httpGet:
+              path: /api/v2.0/
+              port: 5001
+          # Limit to 384MB memory. This is probably *not* enough but it is
+          # necessary in the current environment to allow for 2 replicas and
+          # rolling updates, without hitting the (very aggressive) memory quota.
+          resources:
+            limits:
+              memory: 384Mi
+              cpu: 0.3
+        volumes:
+        - name: config-volume
+          secret:
+            secretName: "resultsdb-test-${TEST_ID}-config"
+        - name: httpd-config-volume
+          configMap:
+            name: "resultsdb-test-${TEST_ID}-httpd-config"
+    triggers:
+    - type: ConfigChange

data/pyproject.toml

@@ -0,0 +1,71 @@
+[tool.poetry]
+name = "resultsdb"
+version = "2.2.0"
+description = "The test results store engine for (not only) Fedora QA tools"
+authors = [
+  "Red Hat, Inc. and others"
+]
+license = "GPL-2.0-or-later"
+readme = "README.md"
+repository = "https://github.com/release-engineering/resultsdb"
+homepage = "https://docs.resultsdb20.apiary.io/"
+
+include = [
+    "LICENSE",
+    "README.md",
+    "alembic.ini",
+    "tox.ini",
+    "resultsdb/templates/*",
+    "resultsdb/static/*",
+    "resultsdb/alembic/*",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.12,<3.14"
+flask = "^3.0.1"
+gunicorn = "^23.0.0"
+fedora-messaging = "^3.4.1"
+stomp_py = "^8.2.0"
+
+pytest = {version = "^8.3.3", optional = true}
+pytest-cov = {version = "^6.0.0", optional = true}
+
+Flask-SQLAlchemy = "^3.1.1"
+SQLAlchemy = {version = "^2.0.36"}
+psycopg2-binary = {version = "^2.9.10"}
+alembic = "^1.13.3"
+iso8601 = "^2.1.0"
+pydantic = "^2.10.2"
+Flask-Pydantic = "^0.13.0"
+
+email-validator = "^2.2.0"
+python-ldap = "^3.4.3"
+Flask-pyoidc = "^3.14.3"
+Flask-Session = "^0.8.0"
+
+# tracing support
+opentelemetry-exporter-otlp = "^1.25.0"
+opentelemetry-instrumentation = "^0.46b0"
+opentelemetry-instrumentation-flask = "^0.46b0"
+opentelemetry-instrumentation-sqlalchemy = "^0.46b0"
+tenacity = "^9.0.0"
+
+mod-wsgi = "^5.0.2"
+
+[tool.poetry.extras]
+test = [
+    "pytest",
+    "pytest-cov",
+]
+
+[tool.poetry.scripts]
+resultsdb = "resultsdb.__main__:cli"
+
+[tool.poetry.plugins."resultsdb.messaging.plugins"]
+dummy = "resultsdb.messaging:DummyPlugin"
+fedmsg = "resultsdb.messaging:FedmsgPlugin"
+stomp = "resultsdb.messaging:StompPlugin"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

data/renovate.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:best-practices",
+    ":enablePreCommit",
+    "group:all",
+    ":gitSignOff",
+    ":disableDependencyDashboard",
+    "schedule:weekly"
+  ],
+  "packageRules": [
+    {
+      "description": "Patch and digest updates",
+      "matchUpdateTypes": [
+        "major",
+        "minor",
+        "patch",
+        "digest"
+      ],
+      "groupName": "all dependencies",
+      "automerge": true,
+      "platformAutomerge": true
+    }
+  ],
+  "constraints": {
+    "python": ">=3.12,<3.14"
+  },
+  "configMigration": true
+}

data/resultsdb/__init__.py

@@ -0,0 +1,317 @@
+# Copyright 2013-2014, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Josef Skladanka <[email protected]>
+#   Ralph Bean <[email protected]>
+
+import json
+import logging
+import logging.config as logging_config
+import logging.handlers
+import os
+
+from flask import Flask, current_app, jsonify, send_from_directory, session
+from flask_pydantic.exceptions import ValidationError
+from flask_pyoidc import OIDCAuthentication
+from flask_pyoidc.provider_configuration import (
+    ClientMetadata,
+    ProviderConfiguration,
+    ProviderMetadata,
+)
+from flask_pyoidc.user_session import UserSession
+from flask_session import Session
+
+from resultsdb.controllers.api_v2 import api as api_v2
+from resultsdb.controllers.api_v3 import api as api_v3
+from resultsdb.controllers.api_v3 import create_endpoints
+from resultsdb.controllers.main import main
+from resultsdb.messaging import load_messaging_plugin
+from resultsdb.models import db
+from resultsdb.proxy import ReverseProxied
+from resultsdb.tracing import setup_tracing
+
+from . import config
+
+# the version as used in setup.py
+__version__ = "2.2.0"
+
+VALIDATION_KEYS = frozenset({"input", "loc", "msg", "type", "url"})
+
+
+def create_app(config_obj=None):
+    app = Flask(__name__)
+    app.secret_key = "replace-me-with-something-random"  # nosec # NOSONAR
+
+    # make sure app behaves when behind a proxy
+    app.wsgi_app = ReverseProxied(app.wsgi_app)
+
+    # Expose the __version__ variable in templates
+    app.jinja_env.globals["app_version"] = __version__
+
+    # Checks for env variable OPENSHIFT_PROD to trigger OpenShift codepath on init
+    # The main difference is that settings will be queried from env
+    # (check config.openshift_config())
+    # Possible values are:
+    # "1" - OpenShift production deployment
+    # "0" - OpenShift testing deployment
+    openshift = os.getenv("OPENSHIFT_PROD")
+
+    # Load default config, then override that with a config file
+    if not config_obj:
+        if os.getenv("DEV") == "true":
+            config_obj = "resultsdb.config.DevelopmentConfig"
+        elif os.getenv("TEST") == "true" or openshift == "0":
+            config_obj = "resultsdb.config.TestingConfig"
+        else:
+            config_obj = "resultsdb.config.ProductionConfig"
+
+    app.config.from_object(config_obj)
+
+    if openshift:
+        config.openshift_config(app.config, openshift)
+
+    default_config_file = app.config["DEFAULT_CONFIG_FILE"]
+    config_file = os.environ.get("RESULTSDB_CONFIG", default_config_file)
+    if config_file and os.path.exists(config_file):
+        app.config.from_pyfile(config_file)
+
+    if app.config["PRODUCTION"]:
+        if app.secret_key == "replace-me-with-something-random":  # nosec # NOSONAR
+            raise Warning("You need to change the app.secret_key value for production")
+
+    setup_logging(app)
+
+    app.logger.info("Using configuration object: %s", config_obj)
+    if openshift:
+        app.logger.info("Using OpenShift configuration")
+    app.logger.info("Using configuration file: %s", config_file)
+
+    if app.config["SHOW_DB_URI"]:
+        app.logger.debug("Using DBURI: %s", app.config["SQLALCHEMY_DATABASE_URI"])
+
+    db.init_app(app)
+
+    with app.app_context():
+        setup_tracing(app, db.engine)
+
+    init_session(app)
+
+    register_handlers(app)
+
+    app.register_blueprint(main)
+    app.register_blueprint(api_v2, url_prefix="/api/v2.0")
+    app.add_url_rule("/favicon.png", view_func=favicon)
+
+    if app.config["AUTH_MODULE"] == "oidc":
+        app.logger.info("OpenIDConnect authentication is enabled")
+        enable_oidc(app)
+        app.register_blueprint(api_v3, url_prefix="/api/v3")
+    else:
+        app.logger.info("OpenIDConnect authentication is disabled")
+
+    setup_messaging(app)
+
+    app.logger.debug("Finished ResultsDB initialization")
+    return app
+
+
+def setup_logging(app):
+    # Use LOGGING if defined instead of the old options
+    log_config = app.config.get("LOGGING")
+    if log_config:
+        logging_config.dictConfig(log_config)
+        return
+
+    fmt = "[%(filename)s:%(lineno)d] " if app.debug else "%(module)-12s "
+    fmt += "%(asctime)s %(levelname)-7s %(message)s"
+    datefmt = "%Y-%m-%d %H:%M:%S"
+    loglevel = logging.DEBUG if app.debug else logging.INFO
+    formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
+
+    root_logger = logging.getLogger("")
+    root_logger.setLevel(logging.DEBUG)
+
+    # Keep the old way to setup logging in settings.py or config.py, example:
+    # LOGFILE = '/var/log/resultsdb/resultsdb.log'
+    # FILE_LOGGING = False
+    # SYSLOG_LOGGING = False
+    # STREAM_LOGGING = True
+    if app.config["STREAM_LOGGING"]:
+        print("doing stream logging")
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(loglevel)
+        stream_handler.setFormatter(formatter)
+        root_logger.addHandler(stream_handler)
+        app.logger.addHandler(stream_handler)
+
+    if app.config["SYSLOG_LOGGING"]:
+        print("doing syslog logging")
+        syslog_handler = logging.handlers.SysLogHandler(
+            address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_LOCAL4
+        )
+        syslog_handler.setLevel(loglevel)
+        syslog_handler.setFormatter(formatter)
+        root_logger.addHandler(syslog_handler)
+        app.logger.addHandler(syslog_handler)
+
+    if app.config["FILE_LOGGING"] and app.config["LOGFILE"]:
+        print(f"doing file logging to {app.config['LOGFILE']}")
+        file_handler = logging.handlers.RotatingFileHandler(
+            app.config["LOGFILE"], maxBytes=500000, backupCount=5
+        )
+        file_handler.setLevel(loglevel)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+        app.logger.addHandler(file_handler)
+
+
+def setup_messaging(app):
+    app.messaging_plugin = None
+    if not app.config["MESSAGE_BUS_PUBLISH"]:
+        app.logger.info("No messaging plugin selected")
+        return
+
+    plugin_name = app.config["MESSAGE_BUS_PLUGIN"]
+    app.logger.info("Using messaging plugin %s", plugin_name)
+    plugin_args = app.config["MESSAGE_BUS_KWARGS"]
+    app.messaging_plugin = load_messaging_plugin(
+        name=plugin_name,
+        plugin_args=plugin_args,
+    )
+
+
+def register_handlers(app):
+    # TODO: find out why error handler works for 404 but not for 400
+    @app.errorhandler(400)
+    def bad_request(error):
+        return jsonify({"message": "Bad request"}), 400
+
+    @app.errorhandler(401)
+    def unauthorized(error):
+        app.logger.warning("Unauthorized access: %s", error)
+        return jsonify({"message": str(error)}), 401
+
+    @app.errorhandler(403)
+    def forbidden(error):
+        app.logger.warning("Permission denied: %s", error)
+        return jsonify({"message": str(error)}), 403
+
+    @app.errorhandler(404)
+    def not_found(error):
+        return jsonify({"message": "Not found"}), 404
+
+    @app.errorhandler(500)
+    def internal_server_error(error):
+        app.logger.error("Internal error: %s", error)
+        return jsonify({"message": "Internal Server Error"}), 500
+
+    @app.errorhandler(502)
+    def bad_gateway(error):
+        app.logger.error("External error received: %s", error)
+        return jsonify({"message": "Bad Gateway"}), 502
+
+    app.register_error_handler(ValidationError, handle_validation_error)
+
+
+def handle_validation_error(error: ValidationError):
+    errors = (
+        error.body_params
+        or error.form_params
+        or error.path_params
+        or error.query_params
+    )
+    # Keep only interesting stuff and remove objects potentially
+    # unserializable in JSON.
+    err = [{k: v for k, v in e.items() if k in VALIDATION_KEYS} for e in errors]
+    response = jsonify({"validation_error": err})
+    response.status_code = 400
+    return response
+
+
+def init_session(app):
+    app.config["SESSION_SQLALCHEMY"] = db
+    app.server_session = Session(app)
+    if app.config["SESSION_TYPE"] == "sqlalchemy":
+        import sqlalchemy
+
+        with app.app_context():
+            inspect = sqlalchemy.inspect(db.engine)
+            table = app.config["SESSION_SQLALCHEMY_TABLE"]
+            if not inspect.has_table(table):
+                db.create_all()
+
+
+def enable_oidc(app):
+    with open(app.config["OIDC_CLIENT_SECRETS"]) as client_secrets_file:
+        client_secrets = json.load(client_secrets_file)
+
+    provider = app.config.get("OIDC_PROVIDER", "web")
+    metadata = client_secrets[provider]
+    app.config.update(
+        {
+            "OIDC_PROVIDER": provider,
+            "OIDC_REDIRECT_URI": metadata["redirect_uris"][0],
+        }
+    )
+    client_metadata = ClientMetadata(metadata["client_id"], metadata["client_secret"])
+    provider_metadata = ProviderMetadata(
+        issuer=metadata["issuer"],
+        authorization_endpoint=metadata["auth_uri"],
+        token_endpoint=metadata["token_uri"],
+        userinfo_endpoint=metadata["userinfo_uri"],
+        introspection_endpoint=metadata["token_introspection_uri"],
+        jwks_uri=metadata.get(
+            "jwks_uri", metadata["token_uri"].replace("/token", "/certs")
+        ),
+    )
+    config = ProviderConfiguration(
+        issuer=metadata["issuer"],
+        client_metadata=client_metadata,
+        provider_metadata=provider_metadata,
+        session_refresh_interval_seconds=app.config[
+            "OIDC_SESSION_REFRESH_INTERVAL_SECONDS"
+        ],
+    )
+    oidc = OIDCAuthentication({provider: config}, app)
+
+    @app.route("/auth/oidclogin")
+    @oidc.oidc_auth(provider)
+    def login():
+        user_session = UserSession(session)
+        return jsonify(
+            {
+                "username": user_session.userinfo[app.config["OIDC_USERNAME_FIELD"]],
+                "token": user_session.access_token,
+            }
+        )
+
+    @app.route("/auth/logout")
+    @oidc.oidc_logout
+    def logout():
+        return jsonify({"message": "Logged out"})
+
+    app.oidc = oidc
+
+    create_endpoints(oidc, provider)
+
+
+def favicon():
+    return send_from_directory(
+        os.path.join(current_app.root_path, "static"),
+        "favicon.png",
+        mimetype="image/png",
+    )

data/resultsdb/__main__.py

@@ -0,0 +1,158 @@
+# Copyright 2013, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Josef Skladanka <[email protected]>
+
+import click
+from alembic import command as al_command
+from alembic.config import Config
+from alembic.migration import MigrationContext
+from flask.cli import FlaskGroup
+from sqlalchemy.engine import reflection
+
+from resultsdb import create_app
+from resultsdb.models import db
+from resultsdb.models.results import Group, Result, ResultData, Testcase
+
+
+def get_alembic_config():
+    # the location of the alembic ini file and alembic scripts changes when
+    # installed via package
+    alembic_cfg = Config()
+    alembic_cfg.set_main_option("script_location", "resultsdb:alembic")
+    return alembic_cfg
+
+
+@click.group(cls=FlaskGroup, create_app=create_app)
+def cli():
+    """Management script for ResultsDB server."""
+
+
+@cli.command(name="upgrade_db")
+def upgrade_db():
+    print("Upgrading Database to Latest Revision")
+    alembic_cfg = get_alembic_config()
+    al_command.upgrade(alembic_cfg, "head")
+
+
+@cli.command(name="init_alembic")
+def init_alembic():
+    alembic_cfg = get_alembic_config()
+
+    # check to see if the db has already been initialized by checking for an
+    # alembic revision
+    context = MigrationContext.configure(db.engine.connect())
+    current_rev = context.get_current_revision()
+
+    if not current_rev:
+        print("Initializing alembic")
+        print(" - Setting the current version to the first revision")
+        al_command.stamp(alembic_cfg, "15f5eeb9f635")
+    else:
+        print("Alembic already initialized")
+
+
+@cli.command(name="init_db")
+@click.pass_context
+def initialize_db(ctx):
+    alembic_cfg = get_alembic_config()
+
+    print("Initializing database")
+
+    # check whether the table 'group' exists
+    # if it does, we assume that the database is empty
+    insp = reflection.Inspector.from_engine(db.engine)
+    table_names = insp.get_table_names()
+    if "testcase" not in table_names and "Testcase" not in table_names:
+        print(" - Creating tables")
+        db.create_all()
+        print(" - Stamping alembic's current version to 'head'")
+        al_command.stamp(alembic_cfg, "head")
+
+    # check to see if the db has already been initialized by checking for an
+    # alembic revision
+    context = MigrationContext.configure(db.engine.connect())
+    current_rev = context.get_current_revision()
+    if current_rev:
+        print(f" - Database is currently at rev {current_rev}")
+        ctx.invoke(upgrade_db)
+    else:
+        print("WARN: You need to have your db stamped with an alembic revision")
+        print("      Run 'init_alembic' sub-command first.")
+
+
+@cli.command(name="mock_data")
+def mock_data():
+    print("Populating tables with mock-data")
+
+    if not db.session.query(Testcase).count():
+        print(" - Testcase, Job, Result, ResultData")
+        tc1 = Testcase(ref_url="https://example.com/depcheck", name="depcheck")
+        tc2 = Testcase(ref_url="https://example.com/rpmlint", name="rpmlint")
+
+        j1 = Group(
+            uuid="5b3f47b4-2ba2-11e5-a343-5254007dccf9",
+            ref_url="https://example.com/job1",
+        )
+
+        j2 = Group(
+            uuid="4e575b2c-2ba2-11e5-a343-5254007dccf9",
+            ref_url="https://example.com/job2",
+        )
+
+        r1 = Result(
+            groups=[j1],
+            testcase=tc1,
+            outcome="PASSED",
+            ref_url="https://example.com/r1",
+        )
+        r2 = Result(
+            groups=[j1, j2],
+            testcase=tc1,
+            outcome="FAILED",
+            ref_url="https://example.com/r2",
+        )
+        r3 = Result(
+            groups=[j2],
+            testcase=tc2,
+            outcome="FAILED",
+            ref_url="https://example.com/r2",
+        )
+
+        ResultData(r1, "item", "cabal-rpm-0.8.3-1.fc18")
+        ResultData(r1, "arch", "x86_64")
+        ResultData(r1, "type", "koji_build")
+
+        ResultData(r2, "item", "htop-1.0-1.fc22")
+        ResultData(r2, "arch", "i386")
+        ResultData(r2, "type", "bodhi_update")
+
+        ResultData(r3, "item", "cabal-rpm-0.8.3-1.fc18")
+        ResultData(r3, "arch", "i386")
+        ResultData(r3, "type", "bodhi_update")
+
+        db.session.add(tc1)
+        db.session.add(j1)
+        db.session.add(j2)
+
+        db.session.commit()
+    else:
+        print(" - skipped Testcase, Job, Result, ResultData")
+
+
+if __name__ == "__main__":
+    cli()

data/resultsdb/alembic/env.py

@@ -0,0 +1,80 @@
+# add '.' to the pythonpath to support migration inside development env
+import sys
+
+from alembic import context
+from flask import current_app as app
+from sqlalchemy import engine_from_config, pool
+
+from resultsdb.models import db
+
+sys.path.append(".")
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+# fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+
+target_metadata = db.metadata
+# target_metadata = None
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(url=url, compare_type=True)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+
+    alembic_config = config.get_section(config.config_ini_section)
+
+    alembic_config["sqlalchemy.url"] = app.config["SQLALCHEMY_DATABASE_URI"]
+
+    engine = engine_from_config(
+        alembic_config, prefix="sqlalchemy.", poolclass=pool.NullPool
+    )
+
+    connection = engine.connect()
+    context.configure(connection=connection, target_metadata=target_metadata)
+
+    try:
+        with context.begin_transaction():
+            context.run_migrations()
+    finally:
+        connection.close()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

data/resultsdb/alembic/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

data/resultsdb/alembic/versions/153c416322c2_create_indexes_on_foreign_keys.py

@@ -0,0 +1,33 @@
+"""Create indexes on Foreign Keys
+
+Revision ID: 153c416322c2
+Revises: 17ec41bd6e9a
+Create Date: 2015-04-14 14:30:03.096651
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "153c416322c2"
+down_revision = "17ec41bd6e9a"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_index("result_fk_job_id", "result", ["job_id"], unique=False)
+    op.create_index("result_fk_testcase_id", "result", ["testcase_id"], unique=False)
+    op.create_index(
+        "result_data_fk_result_id", "result_data", ["result_id"], unique=False
+    )
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index("result_data_fk_result_id", table_name="result_data")
+    op.drop_index("result_fk_testcase_id", table_name="result")
+    op.drop_index("result_fk_job_id", table_name="result")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/15f5eeb9f635_initial_revision.py

@@ -0,0 +1,25 @@
+"""Initial revision
+
+Revision ID: 15f5eeb9f635
+Revises:
+Create Date: 2015-02-23 17:40:33.366352
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = "15f5eeb9f635"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    pass
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    pass
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/17ec41bd6e9a_added_uuid_column_to_the_job_table.py

@@ -0,0 +1,28 @@
+"""Added UUID column to the Job table
+
+Revision ID: 17ec41bd6e9a
+Revises: 433d0b5b3b96
+Create Date: 2015-02-23 17:45:57.085449
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "17ec41bd6e9a"
+down_revision = "433d0b5b3b96"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.add_column("job", sa.Column("uuid", sa.String(length=36), nullable=True))
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("job", "uuid")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/34760e10040b_add_aborted_outcome.py

@@ -0,0 +1,76 @@
+"""Add ABORTED outcome
+
+Revision ID: 34760e10040b
+Revises: 4ace44a44bf
+Create Date: 2015-04-21 14:01:41.374105
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy import text
+
+# revision identifiers, used by Alembic.
+revision = "34760e10040b"
+down_revision = "4ace44a44bf"
+branch_labels = None
+depends_on = None
+
+old_values = ("PASSED", "INFO", "FAILED", "ERROR", "WAIVED", "NEEDS_INSPECTION")
+new_values = (
+    "PASSED",
+    "INFO",
+    "FAILED",
+    "ERROR",
+    "WAIVED",
+    "NEEDS_INSPECTION",
+    "ABORTED",
+)
+
+old_enum = sa.Enum(*old_values, name="resultoutcome")
+tmp_enum = sa.Enum(*new_values, name="resultoutcome_tmp")
+new_enum = sa.Enum(*new_values, name="resultoutcome")
+
+
+def upgrade():
+    # this migration is postgresql specific and fails on sqlite
+    if op.get_bind().engine.url.drivername.startswith("postgresql"):
+        tmp_enum.create(op.get_bind(), checkfirst=False)
+        op.execute(
+            text(
+                "ALTER TABLE result ALTER COLUMN outcome TYPE resultoutcome_tmp "
+                " USING outcome::text::resultoutcome_tmp"
+            )
+        )
+        old_enum.drop(op.get_bind(), checkfirst=False)
+        new_enum.create(op.get_bind(), checkfirst=False)
+        op.execute(
+            text(
+                "ALTER TABLE result ALTER COLUMN outcome TYPE resultoutcome "
+                " USING outcome::text::resultoutcome"
+            )
+        )
+        tmp_enum.drop(op.get_bind(), checkfirst=False)
+
+
+def downgrade():
+    # this migration is postgresql specific and fails on sqlite
+    if op.get_bind().engine.url.drivername.startswith("postgresql"):
+        op.execute(text("UPDATE result SET outcome='ERROR' WHERE outcome='ABORTED'"))
+
+        tmp_enum.create(op.get_bind(), checkfirst=False)
+        op.execute(
+            text(
+                "ALTER TABLE result ALTER COLUMN outcome TYPE resultoutcome_tmp "
+                " USING outcome::text::resultoutcome_tmp"
+            )
+        )
+        new_enum.drop(op.get_bind(), checkfirst=False)
+        old_enum.create(op.get_bind(), checkfirst=False)
+        op.execute(
+            text(
+                "ALTER TABLE result ALTER COLUMN outcome TYPE resultoutcome "
+                " USING outcome::text::resultoutcome"
+            )
+        )
+        tmp_enum.drop(op.get_bind(), checkfirst=False)

data/resultsdb/alembic/versions/433d0b5b3b96_added_index_on_the_keyval_store.py

@@ -0,0 +1,33 @@
+"""Added index on the Keyval store
+
+Revision ID: 433d0b5b3b96
+Revises: 15f5eeb9f635
+Create Date: 2015-02-24 19:57:57.643189
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "433d0b5b3b96"
+down_revision = "15f5eeb9f635"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(
+        "rd_key_value_idx",
+        "result_data",
+        ["key", "value"],
+        unique=False,
+        mysql_length={"value": 50, "key": 20},
+    )
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index("rd_key_value_idx", table_name="result_data")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/4ace44a44bf_change_index_on_result_data_so_like_can_.py

@@ -0,0 +1,35 @@
+"""Change index on result_data so LIKE can use it
+
+Revision ID: 4ace44a44bf
+Revises: 153c416322c2
+Create Date: 2015-04-14 17:20:32.575195
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4ace44a44bf"
+down_revision = "153c416322c2"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(
+        "result_data_idx_key_value",
+        "result_data",
+        ["key", "value"],
+        unique=False,
+        postgresql_ops={"value": "text_pattern_ops", "key": "text_pattern_ops"},
+    )
+    op.drop_index("rd_key_value_idx", table_name="result_data")
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_index("rd_key_value_idx", "result_data", ["key", "value"], unique=False)
+    op.drop_index("result_data_idx_key_value", table_name="result_data")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/4bf1390f06d1_added_index_on_submit_time.py

@@ -0,0 +1,27 @@
+"""Added index on submit_time
+
+Revision ID: 4bf1390f06d1
+Revises: 34760e10040b
+Create Date: 2015-11-03 13:06:35.167227
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4bf1390f06d1"
+down_revision = "34760e10040b"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_index("result_submit_time", "result", ["submit_time"], unique=False)
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index("result_submit_time", table_name="result")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/4dbe714897fe_remove_the_user_model.py

@@ -0,0 +1,31 @@
+"""Remove the user model
+
+Revision ID: 4dbe714897fe
+Revises: dbfab576c81
+Create Date: 2016-10-17 15:52:14.061320
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4dbe714897fe"
+down_revision = "dbfab576c81"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.drop_table("user")
+
+
+def downgrade():
+    op.create_table(
+        "user",
+        sa.Column("id", sa.INTEGER(), nullable=False),
+        sa.Column("username", sa.VARCHAR(length=80), nullable=True),
+        sa.Column("pw_hash", sa.VARCHAR(length=120), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("username"),
+    )

data/resultsdb/alembic/versions/540dbe71fa91_change_schema_to_v2_0_step_1.py

@@ -0,0 +1,186 @@
+"""Change schema to v2.0 - step 1 - prepare columns
+
+Revision ID: 59bef5afc9aa
+Revises: 978007ecd2b
+Create Date: 2016-08-23 20:10:05.734728
+
+"""
+
+import logging
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship, sessionmaker
+from sqlalchemy.orm.decl_api import DeclarativeMeta
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = "540dbe71fa91"
+down_revision = "978007ecd2b"
+branch_labels = None
+depends_on = None
+
+Session = sessionmaker()
+Base: DeclarativeMeta = declarative_base()
+
+
+class Job(Base):
+    __tablename__ = "job"
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    uuid = sa.Column(sa.String(36), unique=True)
+    results = relationship("Result", backref="job")
+
+
+class Result(Base):
+    __tablename__ = "result"
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    job_id = sa.Column(sa.Integer, sa.ForeignKey("job.id"))
+
+
+def upgrade():
+    # Merge duplicate Jobs
+    logger = logging.getLogger("alembic")
+    connection = op.get_bind()
+    session = Session(bind=connection)
+    merge_targets = {}
+    jobs_to_delete = []
+
+    job_count_query = connection.execute(
+        text(
+            "select count(*) from job where uuid in (select uuid from job group by uuid having count(uuid) > 1);"
+        )
+    )
+    job_count = -1
+    for row in job_count_query:
+        job_count = row[0]
+
+    logger.info("Jobs marked for inspection: %s", job_count)
+
+    job_query = (
+        session.query(Job)
+        .from_statement(
+            text(
+                "select id, uuid from job where uuid in (select uuid from job group by uuid having count(uuid) > 1) order by id;"
+            )
+        )
+        .yield_per(100)
+    )
+
+    j = r = 0
+    for job in job_query:
+        j += 1
+        primary = merge_targets.setdefault(job.uuid, job)
+        if primary.id != job.id:
+            for result in job.results:
+                r += 1
+                result.job_id = primary.id
+                session.add(result)
+            jobs_to_delete.append(job)
+        if not j % 1000:
+            logger.info("Jobs seen: %s out of %s", j, job_count)
+            logger.info("Results marked for move: %s", r)
+            session.commit()
+    session.commit()
+    logger.info("Removing duplicate jobs")
+    for job in jobs_to_delete:
+        session.delete(job)
+    session.commit()
+
+    logger.info("Changing table structure")
+
+    # JOB
+    op.rename_table("job", "group")
+    op.alter_column("group", "name", new_column_name="description")
+    op.drop_column("group", "status")
+    op.drop_column("group", "start_time")
+    op.drop_column("group", "end_time")
+    op.create_unique_constraint(None, "group", ["uuid"])
+    op.create_index(
+        "group_idx_uuid",
+        "group",
+        ["uuid"],
+        unique=False,
+        postgresql_ops={"uuid": "text_pattern_ops"},
+    )
+
+    # RESULT
+    op.add_column("result", sa.Column("testcase_name", sa.Text(), nullable=True))
+    op.alter_column("result", "summary", new_column_name="note")
+    op.alter_column("result", "log_url", new_column_name="ref_url")
+    op.create_index(
+        "result_fk_testcase_name",
+        "result",
+        ["testcase_name"],
+        unique=False,
+        postgresql_ops={"testcase_name": "text_pattern_ops"},
+    )
+    op.drop_index("result_fk_job_id", table_name="result")
+    op.drop_index("result_fk_testcase_id", table_name="result")
+    op.drop_constraint("result_testcase_id_fkey", "result", type_="foreignkey")
+    op.drop_constraint("result_job_id_fkey", "result", type_="foreignkey")
+    op.create_foreign_key(None, "result", "testcase", ["testcase_name"], ["name"])
+
+    # TESTCASE
+    op.alter_column("testcase", "url", new_column_name="ref_url")
+
+    # MANY TO MANY
+    op.create_table(
+        "groups_to_results",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("group_uuid", sa.String(36), nullable=True),
+        sa.Column("result_id", sa.Integer(), nullable=True),
+        sa.ForeignKeyConstraint(
+            ["group_uuid"],
+            ["group.uuid"],
+        ),
+        sa.ForeignKeyConstraint(
+            ["result_id"],
+            ["result.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(
+        "gtr_fk_group_uuid",
+        "groups_to_results",
+        ["group_uuid"],
+        unique=False,
+        postgresql_ops={"uuid": "text_pattern_ops"},
+    )
+    op.create_index(
+        "gtr_fk_result_id", "groups_to_results", ["result_id"], unique=False
+    )
+
+
+def downgrade():
+    # TESTCASE
+    op.alter_column("testcase", "ref_url", new_column_name="url")
+
+    # RESULT
+    op.alter_column("result", "note", new_column_name="summary")
+    op.alter_column("result", "ref_url", new_column_name="log_url")
+    op.drop_constraint("result_testcase_name_fkey", "result", type_="foreignkey")
+    op.create_index("result_fk_testcase_id", "result", ["testcase_id"], unique=False)
+    op.create_index("result_fk_job_id", "result", ["job_id"], unique=False)
+    op.drop_index("result_fk_testcase_name", table_name="result")
+    op.drop_column("result", "testcase_name")
+
+    # JOB
+    op.rename_table("group", "job")
+    op.alter_column("job", "description", new_column_name="name")
+    op.add_column("job", sa.Column("end_time", sa.DateTime(), nullable=True))
+    op.add_column("job", sa.Column("start_time", sa.DateTime(), nullable=True))
+    op.add_column("job", sa.Column("status", sa.VARCHAR(length=16), nullable=True))
+    op.drop_index("group_idx_uuid", table_name="job")
+
+    # MANY TO MANY
+    op.drop_index("gtr_fk_result_id", table_name="groups_to_results")
+    op.drop_index("gtr_fk_group_uuid", table_name="groups_to_results")
+    op.drop_table("groups_to_results")
+
+    # CONSTRAINTS
+    op.create_foreign_key(None, "result", "job", ["job_id"], ["id"])
+    op.create_foreign_key(None, "result", "testcase", ["testcase_id"], ["id"])
+    op.drop_constraint("group_uuid_key", "job")

data/resultsdb/alembic/versions/978007ecd2b_changed_testcase_name_to_text.py

@@ -0,0 +1,36 @@
+"""Changed testcase.name to text
+
+Revision ID: 978007ecd2b
+Revises: 4bf1390f06d1
+Create Date: 2016-02-18 21:41:04.273020
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "978007ecd2b"
+down_revision = "4bf1390f06d1"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column("testcase", "name", type_=sa.Text)
+    op.create_index(
+        "testcase_idx_name",
+        "testcase",
+        ["name"],
+        unique=False,
+        postgresql_ops={"name": "text_pattern_ops"},
+    )
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column("testcase", "name", type_=sa.String(255))
+    op.drop_index("testcase_idx_name", table_name="testcase")
+    ### end Alembic commands ###

data/resultsdb/alembic/versions/cd581d0e83df_change_outcome_from_enum_to_string.py

@@ -0,0 +1,37 @@
+"""Change outcome from enum to string.
+
+Revision ID: cd581d0e83df
+Revises: 4dbe714897fe
+Create Date: 2018-03-28 20:47:27.338605
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy import text
+
+# revision identifiers, used by Alembic.
+revision = "cd581d0e83df"
+down_revision = "4dbe714897fe"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.alter_column("result", "outcome", type_=sa.String(32))
+    op.create_index(
+        "result_idx_outcome",
+        "result",
+        ["outcome"],
+        unique=False,
+        postgresql_ops={"outcome": "text_pattern_ops"},
+    )
+
+
+def downgrade():
+    op.execute(
+        text(
+            "ALTER TABLE result ALTER COLUMN outcome TYPE resultoutcome USING outcome::resultoutcome;"
+        )
+    )
+    op.drop_index("result_idx_outcome", table_name="result")

data/resultsdb/alembic/versions/dbfab576c81_change_schema_to_v2_0_step_2.py

@@ -0,0 +1,130 @@
+"""Change schema to v2.0 - step 2 - data migration
+
+Revision ID: dbfab576c81
+Revises: 540dbe71fa91
+Create Date: 2016-08-23 23:02:56.928292
+
+"""
+
+import logging
+import uuid
+
+import sqlalchemy as db
+from alembic import op
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship, sessionmaker
+from sqlalchemy.orm.decl_api import DeclarativeMeta
+
+# revision identifiers, used by Alembic.
+revision = "dbfab576c81"
+down_revision = "540dbe71fa91"
+branch_labels = None
+depends_on = None
+
+Session = sessionmaker()
+Base: DeclarativeMeta = declarative_base()
+
+
+db.relationship = relationship
+
+
+class GroupsToResults(Base):
+    __tablename__ = "groups_to_results"
+    id = db.Column(db.Integer, primary_key=True)
+    group_uuid = db.Column(db.String(36), db.ForeignKey("group.uuid"))
+    result_id = db.Column(db.Integer, db.ForeignKey("result.id"))
+
+
+class Group(Base):
+    __tablename__ = "group"
+
+    id = db.Column(db.Integer, primary_key=True)
+    uuid = db.Column(db.String(36), unique=True)
+
+
+#    results = db.relationship("Result", secondary = 'groups_to_results', backref="groups")
+
+
+class Testcase(Base):
+    __tablename__ = "testcase"
+
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.Text, unique=True)
+
+
+def upgrade():
+    class Result(Base):
+        __tablename__ = "result"
+
+        id = db.Column(db.Integer, primary_key=True)
+        job_id = db.Column(db.Integer, db.ForeignKey("group.id"))
+        testcase_id = db.Column(db.Integer, db.ForeignKey("testcase.id"))
+        testcase_name = db.Column(db.Text)
+
+        groups = db.relationship(
+            "Group", secondary="groups_to_results", backref="results"
+        )
+        job = db.relationship("Group")  # , lazy = False)
+        testcase = db.relationship("Testcase", backref="results")  # , lazy = False)
+
+    logger = logging.getLogger("alembic")
+    connection = op.get_bind()
+    session = Session(bind=connection)
+    i = 0
+    for group in session.query(Group).yield_per(100):
+        i += 1
+        if not group.uuid:
+            group.uuid = str(uuid.uuid1())
+            session.add(group)
+        if not i % 1000:
+            logger.info("Traversed %s groups", i)
+            session.commit()
+    logger.info("Final group commit")
+    session.commit()
+    i = 0
+    logger.info("Starting results")
+    for result in session.query(Result).yield_per(100):
+        i += 1
+        result.groups = [result.job]
+        result.testcase_name = result.testcase.name
+        session.add(result)
+        if not i % 1000:
+            logger.info("Traversed %s results", i)
+            session.commit()
+    logger.info("Final result commit")
+    session.commit()
+    logger.info("Removing the columns")
+    op.drop_column("result", "testcase_id")
+    op.drop_column("result", "job_id")
+
+
+def downgrade():
+    class Result(Base):
+        __tablename__ = "result"
+
+        id = db.Column(db.Integer, primary_key=True)
+        job_id = db.Column(db.Integer, db.ForeignKey("group.id"))
+        testcase_id = db.Column(db.Integer)
+        testcase_name = db.Column(db.Text, db.ForeignKey("testcase.name"))
+
+        groups = db.relationship(
+            "Group", secondary="groups_to_results", backref="results"
+        )
+        job = db.relationship("Group")  # , lazy = False)
+        testcase = db.relationship("Testcase", backref="results")  # , lazy = False)
+
+    op.add_column(
+        "result", db.Column("job_id", db.INTEGER(), autoincrement=False, nullable=True)
+    )
+    op.add_column(
+        "result",
+        db.Column("testcase_id", db.INTEGER(), autoincrement=False, nullable=True),
+    )
+
+    connection = op.get_bind()
+    session = Session(bind=connection)
+    for result in session.query(Result):
+        result.job_id = result.groups[0].id
+        result.testcase_id = result.testcase.id
+        session.add(result)
+        session.commit()

data/resultsdb/authorization.py

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: GPL-2.0+
+import logging
+from fnmatch import fnmatch
+
+from werkzeug.exceptions import BadGateway, Forbidden, InternalServerError
+
+log = logging.getLogger(__name__)
+
+LDAP_ERROR = "Some error occurred initializing the LDAP connection"
+
+
+def get_group_membership(ldap, user, con, ldap_search):
+    try:
+        results = con.search_s(
+            ldap_search["BASE"],
+            ldap.SCOPE_SUBTREE,
+            ldap_search.get("SEARCH_STRING", "(memberUid={user})").format(user=user),
+            ["cn"],
+        )
+        return [group[1]["cn"][0].decode("utf-8") for group in results]
+    except KeyError:
+        log.exception("LDAP_SEARCHES parameter should contain the BASE key")
+        raise InternalServerError("LDAP_SEARCHES parameter should contain the BASE key")
+    except ldap.SERVER_DOWN:
+        log.exception("The LDAP server is not reachable")
+        raise BadGateway("The LDAP server is not reachable")
+    except ldap.LDAPError:
+        log.exception(LDAP_ERROR)
+        raise BadGateway(LDAP_ERROR)
+
+
+def match_testcase_permissions(testcase, permissions):
+    for permission in permissions:
+        if "testcases" in permission:
+            testcase_match = any(
+                fnmatch(testcase, testcase_pattern)
+                for testcase_pattern in permission["testcases"]
+            )
+            if testcase_match:
+                yield permission
+
+
+def verify_authorization(user, testcase, permissions, ldap_host, ldap_searches):
+    """
+    Raises an exception if the user is not permitted to publish a result for
+    the testcase.
+    """
+    if not (ldap_host and ldap_searches):
+        raise InternalServerError(
+            "LDAP_HOST and LDAP_SEARCHES also need to be defined if PERMISSIONS is defined"
+        )
+
+    allowed_groups = []
+    for permission in match_testcase_permissions(testcase, permissions):
+        if user in permission.get("users", []):
+            return
+        allowed_groups += permission.get("groups", [])
+
+    try:
+        import ldap
+    except ImportError:
+        raise InternalServerError(
+            "If PERMISSIONS is defined, python-ldap needs to be installed"
+        )
+
+    try:
+        con = ldap.initialize(ldap_host)
+    except ldap.LDAPError:
+        log.exception(LDAP_ERROR)
+        raise BadGateway(LDAP_ERROR)
+
+    any_groups_found = False
+    for cur_ldap_search in ldap_searches:
+        groups = get_group_membership(ldap, user, con, cur_ldap_search)
+        if any(g in groups for g in allowed_groups):
+            return
+        any_groups_found = any_groups_found or len(groups) > 0
+
+    raise Forbidden(
+        f"User {user} is not authorized to submit results for the test case {testcase}"
+        + ("" if any_groups_found else "; failed to find the user in LDAP")
+    )

data/resultsdb/config.py

@@ -0,0 +1,205 @@
+# Copyright 2013, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Josef Skladanka <[email protected]>
+#   Ralph Bean <[email protected]>
+
+# For Python 2.7 compatibility
+
+import os
+import sys
+
+
+def db_uri_for_testing():
+    postgres_port = os.getenv("RESULTSDB_POSTGRES_PORT")
+    if postgres_port:
+        return f"postgresql+psycopg2://resultsdb:resultsdb@localhost:{postgres_port}/resultsdb"  # nosec # NOSONAR
+
+    return "sqlite:///.test_db.sqlite"
+
+
+class Config:
+    DEFAULT_CONFIG_FILE: str | None = None
+
+    DEBUG = True
+    PRODUCTION = False
+    SECRET_KEY = "replace-me-with-something-random"  # nosec # NOSONAR
+
+    HOST = "127.0.0.1"
+    PORT = 5001
+
+    SQLALCHEMY_DATABASE_URI = "sqlite://"
+    SHOW_DB_URI = True
+
+    FLASK_PYDANTIC_VALIDATION_ERROR_RAISE = True
+
+    LOGGING = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "loggers": {
+            "resultsdb": {
+                "level": "INFO",
+            },
+            "dogpile": {
+                "level": "WARNING",
+            },
+        },
+        "handlers": {
+            "console": {
+                "formatter": "bare",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+                "level": "INFO",
+            },
+        },
+        "formatters": {
+            "bare": {
+                "format": "[%(asctime)s] [%(process)d] [%(levelname)s] %(name)s: %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            }
+        },
+        "root": {
+            "level": "WARNING",
+            "handlers": ["console"],
+        },
+    }
+
+    # Extend the list of allowed outcomes.
+    ADDITIONAL_RESULT_OUTCOMES: tuple[str] | tuple[()] = ()
+
+    PERMISSIONS: list[dict[str, object]] = []
+
+    # Supported values: "oidc"
+    AUTH_MODULE: str | None = None
+
+    OIDC_CLIENT_SECRETS = "/etc/resultsdb/oauth2_client_secrets.json"
+    OIDC_USERNAME_FIELD = "uid"
+    OIDC_SESSION_REFRESH_INTERVAL_SECONDS = 300
+    OIDC_SESSION_PERMANENT = False
+    PERMANENT_SESSION_LIFETIME = 300
+
+    SESSION_TYPE = "sqlalchemy"
+    SESSION_SQLALCHEMY_TABLE = "sessions"
+    SESSION_PERMANENT = True
+    SESSION_USE_SIGNER = True
+    SESSION_COOKIE_NAME = "session"
+    SESSION_COOKIE_SECURE = True
+    SESSION_COOKIE_SAMESITE = "Lax"
+
+    FEDMENU_URL = "https://apps.fedoraproject.org/fedmenu"
+    FEDMENU_DATA_URL = "https://apps.fedoraproject.org/js/data.js"
+
+    # Set this to True or False to enable publishing to a message bus
+    MESSAGE_BUS_PUBLISH = True
+    # Name of the message bus plugin to use goes here.  'fedmsg' is installed by
+    # default, but you could create your own.
+    # Supported values: 'dummy', 'stomp', 'fedmsg'
+    MESSAGE_BUS_PLUGIN = "dummy"
+    # You can pass extra arguments to your message bus plugin here.  For instance,
+    # the fedmsg plugin expects an extra `modname` argument that can be used to
+    # configure the topic, like this:
+    #   <topic_prefix>.<environment>.<modname>.<topic>
+    # e.g. org.fedoraproject.prod.resultsdb.result.new
+    MESSAGE_BUS_KWARGS: dict[str, object] = {}
+
+    # Publish Taskotron-compatible fedmsgs on the 'taskotron' topic
+    MESSAGE_BUS_PUBLISH_TASKOTRON = False
+    OTEL_EXPORTER_OTLP_METRICS_ENDPOINT = None
+    OTEL_EXPORTER_SERVICE_NAME = "resultsdb"
+
+
+class ProductionConfig(Config):
+    DEFAULT_CONFIG_FILE = "/etc/resultsdb/settings.py"
+    DEBUG = False
+    PRODUCTION = True
+    SHOW_DB_URI = False
+    MESSAGE_BUS_PLUGIN = "fedmsg"
+    MESSAGE_BUS_KWARGS = {"modname": "resultsdb"}
+
+
+class DevelopmentConfig(Config):
+    DEFAULT_CONFIG_FILE = os.getcwd() + "/conf/settings.py"
+    TRAP_BAD_REQUEST_ERRORS = True
+    SQLALCHEMY_DATABASE_URI = "sqlite:////var/tmp/resultsdb_db.sqlite"
+    OIDC_CLIENT_SECRETS = os.getcwd() + "/conf/oauth2_client_secrets.json.example"
+
+
+class TestingConfig(Config):
+    TRAP_BAD_REQUEST_ERRORS = True
+
+    SQLALCHEMY_DATABASE_URI = db_uri_for_testing()
+
+    FEDMENU_URL = "https://apps.stg.fedoraproject.org/fedmenu"
+    FEDMENU_DATA_URL = "https://apps.stg.fedoraproject.org/js/data.js"
+    ADDITIONAL_RESULT_OUTCOMES = ("AMAZING",)
+    MESSAGE_BUS_PLUGIN = "dummy"
+    MESSAGE_BUS_KWARGS = {}
+    PERMISSIONS = [
+        {
+            "users": ["testuser1"],
+            "testcases": ["testcase1"],
+        }
+    ]
+    AUTH_MODULE = "oidc"
+    LDAP_HOST = "ldap://ldap.example.com"
+    LDAP_SEARCHES = [
+        {
+            "BASE": "ou=Groups,dc=example,dc=com",
+            "SEARCH_STRING": "(memberUid={user})",
+        }
+    ]
+
+    OIDC_CLIENT_SECRETS = os.getcwd() + "/conf/oauth2_client_secrets.json.example"
+
+
+def openshift_config(config_object, openshift_production):
+    # First, get db details from env
+    try:
+        config_object["SQLALCHEMY_DATABASE_URI"] = (
+            "postgresql+psycopg2://{}:{}@{}:{}/{}".format(
+                os.environ["POSTGRESQL_USER"],
+                os.environ["POSTGRESQL_PASSWORD"],
+                os.environ["POSTGRESQL_SERVICE_HOST"],
+                os.environ["POSTGRESQL_SERVICE_PORT"],
+                os.environ["POSTGRESQL_DATABASE"],
+            )
+        )
+        config_object["SECRET_KEY"] = os.environ["SECRET_KEY"]
+    except KeyError:
+        print(
+            "OpenShift mode enabled but required values couldn't be fetched. "
+            "Check, if you have these variables defined in you env: "
+            "(POSTGRESQL_[USER, PASSWORD, DATABASE, SERVICE_HOST, SERVICE_PORT], "
+            "SECRET_KEY)",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Nuke out messaging, we don't support this in OpenShift mode
+    # Inject settings.py and disable OpenShift mode if you need this
+    config_object["MESSAGE_BUS_PLUGIN"] = "dummy"
+    config_object["MESSAGE_BUS_KWARGS"] = {}
+
+    if os.getenv("MESSAGE_BUS_PLUGIN") or os.getenv("MESSAGE_BUS_KWARGS"):
+        print("It appears you've tried to set up messaging in OpenShift mode.")
+        print(
+            "This is not supported, you need to inject setting.py and disable "
+            "OpenShift mode if you need messaging."
+        )
+
+    # Danger zone, keep this False out in the wild, always
+    config_object["SHOW_DB_URI"] = False

data/resultsdb/controllers/api_v2.py

@@ -0,0 +1,661 @@
+# Copyright 2013-2016, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Josef Skladanka <[email protected]>
+#   Ralph Bean <[email protected]>
+
+import re
+import uuid
+
+from flask import Blueprint
+from flask import current_app as app
+from flask import jsonify, request, url_for
+from flask_pydantic import validate
+from sqlalchemy.orm import exc as orm_exc
+
+from resultsdb.controllers.common import SERIALIZE, commit_result
+from resultsdb.models import db
+from resultsdb.models.results import (
+    Group,
+    Result,
+    ResultData,
+    Testcase,
+    result_outcomes,
+)
+from resultsdb.parsers.api_v2 import (
+    QUERY_LIMIT,
+    CreateGroupParams,
+    CreateResultParams,
+    CreateTestcaseParams,
+    GroupsParams,
+    ResultsParams,
+    TestcasesParams,
+)
+
+api = Blueprint("api_v2", __name__)
+
+
+# =============================================================================
+#                               GLOBAL VARIABLES
+# =============================================================================
+
+RE_PAGE = re.compile(r"([?&])page=([0-9]+)")
+RE_CALLBACK = re.compile(r"([?&])callback=[^&]*&?")
+RE_CLEAN_AMPERSANDS = re.compile(r"&+")
+
+# =============================================================================
+#                               GLOBAL METHODS
+# =============================================================================
+
+
+def pagination(q, page, limit):
+    """
+    Sets the offset/limit for the DB query.
+    limit+1 is purposely set as 'limit' so we can later on decide whether 'next'
+    page link should be provided or set to None.
+    """
+    # pagination offset
+    try:
+        page = int(page)
+        if page > 0:
+            offset = page * limit
+            q = q.offset(offset)
+    except (TypeError, ValueError):
+        pass
+
+    q = q.limit(limit + 1)
+    return q
+
+
+def prev_next_urls(data, limit=QUERY_LIMIT):
+    global RE_PAGE
+
+    try:
+        match = RE_PAGE.findall(request.url)
+        flag, page = match[0][0], int(match[0][1])
+    except IndexError:  # page not found
+        page = None
+
+    prev = None
+    next = None
+    placeholder = "[!@#$%^&*PLACEHOLDER*&^%$#@!]"
+
+    if page is None:
+        if "?" in request.url:
+            baseurl = f"{request.url}&page={placeholder}"
+        else:
+            baseurl = f"{request.url}?page={placeholder}"
+        page = 0
+    else:
+        baseurl = RE_PAGE.sub(f"{flag}page={placeholder}", request.url)
+
+    baseurl = RE_CALLBACK.sub(r"\1", baseurl)
+    baseurl = RE_CLEAN_AMPERSANDS.sub("&", baseurl)
+
+    if page > 0:
+        prev = baseurl.replace(placeholder, str(page - 1))
+    if len(data) > limit:
+        next = baseurl.replace(placeholder, str(page + 1))
+        data = data[:limit]
+
+    return data, prev, next
+
+
+# =============================================================================
+#                                      GROUPS
+# =============================================================================
+
+
+def add_group(grp):
+    if isinstance(grp, (str, bytes)):
+        grp = dict(uuid=grp)
+    elif isinstance(grp, dict):
+        grp["uuid"] = grp.get("uuid", str(uuid.uuid1()))
+
+    group = Group.query.filter_by(uuid=grp["uuid"]).first()
+    if not group:
+        group = Group(uuid=grp["uuid"])
+
+    group.description = grp.get("description", group.description)
+    group.ref_url = grp.get("ref_url", group.ref_url)
+
+    db.session.add(group)
+    return group
+
+
+@api.route("/groups", methods=["GET"])
+@validate()
+def get_groups(query: GroupsParams):
+    q = db.session.query(Group).order_by(db.desc(Group.id))
+
+    desc_filters = []
+    if query.description:
+        for description in query.description.split(","):
+            if not description.strip():
+                continue
+            desc_filters.append(Group.description == description)
+    #        desc_filters.append(Group.description.in_(query.description.split(',')))
+    elif query.description_like_:
+        for description in query.description_like_.split(","):
+            if not description.strip():
+                continue
+            desc_filters.append(Group.description.like(description.replace("*", "%")))
+    if desc_filters:
+        q = q.filter(db.or_(*desc_filters))
+
+    # Filter by uuid
+    if query.uuid:
+        q = q.filter(Group.uuid.in_(query.uuid.split(",")))
+
+    q = pagination(q, query.page, query.limit)
+    data, prev, next = prev_next_urls(q.all(), query.limit)
+
+    return jsonify(
+        dict(
+            prev=prev,
+            next=next,
+            data=[SERIALIZE(o) for o in data],
+        )
+    )
+
+
+@api.route("/groups/<group_id>", methods=["GET"])
+def get_group(group_id):
+    q = Group.query.filter_by(uuid=group_id)
+    group = q.first()
+    if not group:
+        return jsonify({"message": "Group not found"}), 404
+
+    return jsonify(SERIALIZE(group))
+
+
+@api.route("/groups", methods=["POST"])
+@validate()
+def create_group(body: CreateGroupParams):
+    if body.uuid:
+        group = Group.query.filter_by(uuid=body.uuid).first()
+        if not group:
+            group = Group(uuid=body.uuid)
+    else:
+        group = Group(uuid=str(uuid.uuid1()))
+
+    if body.ref_url:
+        group.ref_url = body.ref_url
+    if body.description:
+        group.description = body.description
+
+    db.session.add(group)
+    db.session.commit()
+
+    return jsonify(SERIALIZE(group)), 201
+
+
+# =============================================================================
+#                                     RESULTS
+# =============================================================================
+def select_results(
+    since_start=None,
+    since_end=None,
+    outcomes=None,
+    groups=None,
+    testcases=None,
+    testcases_like=None,
+    result_data=None,
+    _sort=None,
+):
+    # Checks if the sort parameter specified in the request is valid before querying.
+    # Sorts by submit_time in a descending order if the sort parameter is absent or invalid.
+    q = db.session.query(Result)
+    query_sorted = False
+    if _sort:
+        sort_match = re.match(r"^(?P<order>asc|desc):(?P<column>.+)$", _sort)
+        if sort_match and sort_match.group("column") == "submit_time":
+            sort_order = {"asc": db.asc, "desc": db.desc}[sort_match.group("order")]
+            sort_column = getattr(Result, sort_match.group("column"))
+            q = q.order_by(sort_order(sort_column))
+            query_sorted = True
+    if _sort and _sort == "disable_sorting":
+        query_sorted = True
+    if not query_sorted:
+        q = q.order_by(db.desc(Result.submit_time))
+
+    # Time constraints
+    if since_start:
+        q = q.filter(Result.submit_time >= since_start)
+    if since_end:
+        q = q.filter(Result.submit_time <= since_end)
+
+    # Filter by outcome
+    if outcomes:
+        q = q.filter(Result.outcome.in_(outcomes))
+
+    # Filter by group_id
+    if groups:
+        q = q.filter(Result.groups.any(Group.uuid.in_(groups)))
+
+    # Filter by testcase_name
+    filter_by_testcase = []
+    if testcases:
+        filter_by_testcase.append(Result.testcase_name.in_(testcases))
+    if testcases_like:
+        for testcase in testcases_like:
+            testcase = testcase.replace("*", "%")
+            filter_by_testcase.append(Result.testcase_name.like(testcase))
+    if filter_by_testcase:
+        q = q.filter(db.or_(*filter_by_testcase))
+
+    # Filter by result_data
+    if result_data is not None:
+        for key, values in result_data.items():
+            try:
+                key, modifier = key.split(":")
+            except ValueError:  # no : in key
+                key, modifier = (key, None)
+
+            if modifier == "like":
+                alias = db.aliased(ResultData)
+                if len(values) > 1:  # multiple values
+                    likes = []
+                    # create the (value LIKE foo OR value LIKE bar OR ...) part
+                    for value in values:
+                        value = value.replace("*", "%")
+                        likes.append(alias.value.like(value))
+                    # put it together to (key = key AND (value LIKE foo OR value LIKE bar OR ...))
+                    q = q.join(alias).filter(db.and_(alias.key == key, db.or_(*likes)))
+                else:
+                    value = values[0].replace("*", "%")
+                    q = q.join(alias).filter(
+                        db.and_(alias.key == key, alias.value.like(value))
+                    )
+
+            else:
+                alias = db.aliased(ResultData)
+                q = q.join(alias).filter(
+                    db.and_(alias.key == key, alias.value.in_(values))
+                )
+    return q
+
+
+def __get_results_parse_args(query: ResultsParams):
+    args = {
+        "_sort": query.sort_,
+        "limit": query.limit,
+        "page": query.page,
+        "testcases": query.testcases,
+        "testcases:like": query.testcases_like_,
+        "groups": query.groups,
+        "_distinct_on": query.distinct_on_,
+        "outcome": query.outcome,
+        "since": query.since,
+    }
+
+    # find results_data with the query parameters
+    #  these are the paramters other than those defined in RequestParser
+    # request.args is a ImmutableMultiDict, which allows for more values to be
+    #  stored in one key (so one can do stuff like .../results?item=foo&item=bar in URL).
+    # Here we transform the `request.args` MultiDict to `results_data` dict of lists, and
+    #  while also filtering out the reserved-keyword-args
+    results_data = {
+        k: request.args.getlist(k) for k in request.args.keys() if k not in args
+    }
+    for param, values in results_data.items():
+        for i, value in enumerate(values):
+            results_data[param][i] = value.split(",")
+        # flatten the list
+        results_data[param] = [
+            item for sublist in results_data[param] for item in sublist
+        ]
+
+    return {
+        "result_data": results_data if results_data else None,
+        "args": args,
+    }
+
+
+def __get_results(query: ResultsParams, group_ids=None, testcase_names=None):
+    p = __get_results_parse_args(query)
+    args = p["args"]
+
+    groups = group_ids if group_ids is not None else args["groups"]
+    testcases = testcase_names if testcase_names is not None else args["testcases"]
+
+    q = select_results(
+        since_start=args["since"]["start"],
+        since_end=args["since"]["end"],
+        outcomes=args["outcome"],
+        groups=groups,
+        testcases=testcases,
+        testcases_like=args["testcases:like"],
+        result_data=p["result_data"],
+        _sort=args["_sort"],
+    )
+
+    q = pagination(q, args["page"], args["limit"])
+    data, prev, next = prev_next_urls(q.all(), args["limit"])
+
+    return jsonify(
+        dict(
+            prev=prev,
+            next=next,
+            data=[SERIALIZE(o) for o in data],
+        )
+    )
+
+
+def add_data_to_result(data, result):
+    to_store = []
+    for key, value in data.items():
+        if not isinstance(key, str):
+            key = str(key)
+
+        if isinstance(value, str):
+            to_store.append((key, value))
+
+        elif isinstance(value, (list, tuple)):
+            for v in value:
+                if not isinstance(v, str):
+                    v = str(v)
+                to_store.append((key, v))
+        else:
+            value = str(value)
+            to_store.append((key, value))
+
+    for key, value in to_store:
+        ResultData(result, key, value)
+
+
+@api.route("/results", methods=["GET"])
+@validate()
+def get_results(query: ResultsParams):
+    return __get_results(query)
+
+
+@api.route("/results/latest", methods=["GET"])
+@validate()
+def get_results_latest(query: ResultsParams):
+    p = __get_results_parse_args(query)
+    args = p["args"]
+    since_start = args["since"].get("start", None)
+    since_end = args["since"].get("end", None)
+    groups = args.get("groups", None)
+    testcases = args.get("testcases", None)
+    testcases_like = args.get("testcases:like", None)
+    distinct_on = args.get("_distinct_on", None)
+
+    if not distinct_on:
+        q = select_results(
+            since_start=since_start,
+            since_end=since_end,
+            groups=groups,
+            testcases=testcases,
+            testcases_like=testcases_like,
+            result_data=p["result_data"],
+        )
+
+        # Produce a subquery with the same filter criteria as above *except*
+        # test case name, which we group by and join on.
+        sq = (
+            select_results(
+                since_start=since_start,
+                since_end=since_end,
+                groups=groups,
+                result_data=p["result_data"],
+            )
+            .order_by(None)
+            .with_entities(
+                Result.testcase_name.label("testcase_name"),
+                db.func.max(Result.submit_time).label("max_submit_time"),
+            )
+            .group_by(Result.testcase_name)
+            .subquery()
+        )
+        q = q.join(
+            sq,
+            db.and_(
+                Result.testcase_name == sq.c.testcase_name,
+                Result.submit_time == sq.c.max_submit_time,
+            ),
+        )
+
+        results = q.all()
+
+        return jsonify(
+            dict(
+                data=[SERIALIZE(o) for o in results],
+            )
+        )
+
+    if not any(
+        [testcases, testcases_like, since_start, since_end, groups, p["result_data"]]
+    ):
+        return (
+            jsonify(
+                {
+                    "message": (
+                        "Please, provide at least one filter beside '_distinct_on'"
+                    )
+                }
+            ),
+            400,
+        )
+
+    q = db.session.query(Result)
+    q = select_results(
+        since_start=since_start,
+        since_end=since_end,
+        groups=groups,
+        testcases=testcases,
+        testcases_like=testcases_like,
+        result_data=p["result_data"],
+        _sort="disable_sorting",
+    )
+
+    values_distinct_on = [Result.testcase_name]
+    for i, key in enumerate(distinct_on):
+        name = f"result_data_{i}_{key}"
+        alias = db.aliased(
+            db.session.query(ResultData).filter(ResultData.key == key).subquery(),
+            name=name,
+        )
+        q = q.outerjoin(alias)
+        values_distinct_on.append(db.text(f"{name}.value"))
+
+    q = q.distinct(*values_distinct_on)
+    q = q.order_by(*values_distinct_on).order_by(db.desc(Result.submit_time))
+
+    results = q.all()
+    results = dict(
+        data=[SERIALIZE(o) for o in results],
+    )
+    results["data"] = sorted(
+        results["data"], key=lambda x: x["submit_time"], reverse=True
+    )
+    return jsonify(results)
+
+
+@api.route("/groups/<group_id>/results", methods=["GET"])
+@validate()
+def get_results_by_group(group_id: str, query: ResultsParams):
+    group = Group.query.filter_by(uuid=group_id).first()
+    if not group:
+        return jsonify({"message": f"Group not found: {group_id}"}), 404
+    return __get_results(query, group_ids=[group.uuid])
+
+
+@api.route("/testcases/<path:testcase_name>/results", methods=["GET"])
+@validate()
+def get_results_by_testcase(testcase_name: str, query: ResultsParams):
+    testcase = Testcase.query.filter_by(name=testcase_name).first()
+    if not testcase:
+        return jsonify({"message": "Testcase not found"}), 404
+    return __get_results(query, testcase_names=[testcase.name])
+
+
+@api.route("/results/<result_id>", methods=["GET"])
+def get_result(result_id):
+    try:
+        result = Result.query.filter_by(id=result_id).one()
+    except orm_exc.NoResultFound:
+        return jsonify({"message": "Result not found"}), 404
+
+    return jsonify(SERIALIZE(result))
+
+
+@api.route("/results", methods=["POST"])
+@validate()
+def create_result(body: CreateResultParams):
+    return create_result_any_data(body)
+
+
+def create_result_any_data(body: CreateResultParams):
+    """
+    Allows creating test results with data not checked by any schema (in
+    contrast to v3 API).
+    """
+    if body.data:
+        invalid_keys = [key for key in body.data.keys() if ":" in key]
+        if invalid_keys:
+            app.logger.warning("Colon not allowed in key name: %s", invalid_keys)
+            return jsonify(
+                {"message": "Colon not allowed in key name: %r" % invalid_keys}
+            ), 400
+
+    tc = body.testcase
+
+    testcase = Testcase.query.filter_by(name=tc["name"]).first()
+    if not testcase:
+        app.logger.debug("Testcase %s does not exist yet. Creating", tc["name"])
+        testcase = Testcase(name=tc["name"])
+    testcase.ref_url = tc.get("ref_url", testcase.ref_url)
+    db.session.add(testcase)
+
+    # groups is a list of strings(uuid) or dicts(group object)
+    #  when a group defined by the string is not found, new is created
+    #  group defined by the object, is updated/created with the values from the object
+    # non-existing groups are created automatically
+    groups = [add_group(group) for group in (body.groups or [])]
+
+    result = Result(
+        testcase, body.outcome, groups, body.ref_url, body.note, body.submit_time
+    )
+
+    if isinstance(body.data, dict):
+        add_data_to_result(body.data, result)
+
+    return commit_result(result)
+
+
+# =============================================================================
+#                                    TESTCASES
+# =============================================================================
+
+
+def select_testcases(args_name=None, args_name_like=None):
+    q = db.session.query(Testcase).order_by(db.asc(Testcase.name))
+
+    name_filters = []
+    if args_name:
+        for name in [name.strip() for name in args_name.split(",") if name.strip()]:
+            name_filters.append(Testcase.name == name)
+    elif args_name_like:
+        for name in [
+            name.strip() for name in args_name_like.split(",") if name.strip()
+        ]:
+            name_filters.append(Testcase.name.like(name.replace("*", "%")))
+    if name_filters:
+        q = q.filter(db.or_(*name_filters))
+
+    return q
+
+
+@api.route("/testcases", methods=["GET"])
+@validate()
+def get_testcases(query: TestcasesParams):
+    q = select_testcases(query.name, query.name_like_)
+    q = pagination(q, query.page, query.limit)
+    data, prev, next = prev_next_urls(q.all(), query.limit)
+
+    return jsonify(
+        dict(
+            prev=prev,
+            next=next,
+            data=[SERIALIZE(o) for o in data],
+        )
+    )
+
+
+@api.route("/testcases/<path:testcase_name>", methods=["GET"])
+def get_testcase(testcase_name):
+    try:
+        testcase = Testcase.query.filter_by(name=testcase_name).one()
+    except orm_exc.NoResultFound:
+        return jsonify({"message": "Testcase not found"}), 404
+
+    return jsonify(SERIALIZE(testcase))
+
+
+@api.route("/testcases", methods=["POST"])
+@validate()
+def create_testcase(body: CreateTestcaseParams):
+    testcase = Testcase.query.filter_by(name=body.name).first()
+    if not testcase:
+        testcase = Testcase(name=body.name)
+    if body.ref_url is not None:
+        testcase.ref_url = body.ref_url
+
+    db.session.add(testcase)
+    db.session.commit()
+
+    return jsonify(SERIALIZE(testcase)), 201
+
+
+@api.route("/healthcheck", methods=["GET"])
+def healthcheck():
+    """
+    Request handler for performing an application-level health check. This is
+    not part of the published API, it is intended for use by OpenShift or other
+    monitoring tools.
+
+    Returns a 200 response if the application is alive and able to serve requests.
+    """
+    try:
+        db.session.execute(db.text("SELECT 1 FROM result LIMIT 0")).fetchall()
+    except Exception:
+        app.logger.exception("Healthcheck failed on DB query.")
+        return jsonify({"message": "Unable to communicate with database"}), 503
+
+    return jsonify({"message": "Health check OK"}), 200
+
+
+@api.route("", methods=["GET"])
+@api.route("/", methods=["GET"])
+def landing_page():
+    return (
+        jsonify(
+            {
+                "message": "Everything is fine. But choose wisely, for while "
+                "the true Grail will bring you life, the false "
+                "Grail will take it from you.",
+                "documentation": "https://docs.resultsdb20.apiary.io/",
+                "groups": url_for(".get_groups", _external=True),
+                "results": url_for(".get_results", _external=True),
+                "testcases": url_for(".get_testcases", _external=True),
+                "outcomes": result_outcomes(),
+            }
+        ),
+        300,
+    )

data/resultsdb/controllers/api_v3.py

@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: GPL-2.0+
+from flask import Blueprint
+from flask import current_app as app
+from flask import jsonify, render_template
+from flask_pydantic import validate
+from pydantic import RootModel
+
+from resultsdb.authorization import (
+    match_testcase_permissions,
+    verify_authorization,
+)
+from resultsdb.controllers.api_v2 import create_result_any_data
+from resultsdb.controllers.common import commit_result
+from resultsdb.models import db
+from resultsdb.models.results import Result, ResultData, Testcase
+from resultsdb.parsers.api_v2 import CreateResultParams
+from resultsdb.parsers.api_v3 import (
+    RESULTS_PARAMS_CLASSES,
+    PermissionsParams,
+    ResultParamsBase,
+    result_outcomes_extended,
+)
+
+api = Blueprint("api_v3", __name__)
+
+
+def permissions():
+    return app.config.get("PERMISSIONS", [])
+
+
+def get_authorized_user(testcase) -> str:
+    """
+    Raises an exception if the current user cannot publish a result for the
+    testcase, otherwise returns the name of the current user.
+    """
+    user = app.oidc.current_token_identity[app.config["OIDC_USERNAME_FIELD"]]
+    ldap_host = app.config.get("LDAP_HOST")
+    ldap_searches = app.config.get("LDAP_SEARCHES")
+    verify_authorization(user, testcase, permissions(), ldap_host, ldap_searches)
+    return user
+
+
+def create_result(body: ResultParamsBase):
+    user = get_authorized_user(body.testcase)
+
+    testcase = Testcase.query.filter_by(name=body.testcase).first()
+    if not testcase:
+        app.logger.debug("Testcase %s does not exist yet. Creating", body.testcase)
+        testcase = Testcase(name=body.testcase)
+    if body.testcase_ref_url:
+        app.logger.debug(
+            "Updating ref_url for testcase %s: %s", body.testcase, body.testcase_ref_url
+        )
+        testcase.ref_url = str(body.testcase_ref_url)
+    db.session.add(testcase)
+
+    ref_url = str(body.ref_url) if body.ref_url else None
+
+    result = Result(
+        testcase=testcase,
+        outcome=body.outcome,
+        ref_url=ref_url,
+        note=body.note,
+        groups=[],
+    )
+
+    if user:
+        ResultData(result, "username", user)
+
+    for name, value in body.result_data():
+        ResultData(result, name, value)
+
+    return commit_result(result)
+
+
+def create_endpoint(params_class, oidc, provider):
+    params = params_class.model_construct()
+
+    @oidc.token_auth(provider)
+    @validate()
+    # Using RootModel is a workaround for a bug in flask-pydantic that causes
+    # validation to fail with unexpected exception.
+    def create(body: RootModel[params_class]):
+        return create_result(body.root)
+
+    def get_schema():
+        return jsonify(params.model_construct().model_json_schema()), 200
+
+    artifact_type = params.artifact_type()
+    api.add_url_rule(
+        f"/results/{artifact_type}s",
+        endpoint=f"results_{artifact_type}s",
+        methods=["POST"],
+        view_func=create,
+    )
+    api.add_url_rule(
+        f"/schemas/{artifact_type}s",
+        endpoint=f"schemas_{artifact_type}s",
+        view_func=get_schema,
+    )
+
+
+def create_any_data_endpoint(oidc, provider):
+    """
+    Creates an endpoint that accepts the same data as POST /api/v2.0/results
+    but supports OIDC authentication and permission control.
+
+    Other users/groups won't be able to POST results to this endpoint unless
+    they have a permission mapping with testcase pattern matching
+    "ANY-DATA:<testcase_name>" (instead of just "<testcase_name>" as in the
+    other v3 endpoints).
+    """
+
+    @oidc.token_auth(provider)
+    @validate()
+    # Using RootModel is a workaround for a bug in flask-pydantic that causes
+    # validation to fail with unexpected exception.
+    def create(body: RootModel[CreateResultParams]):
+        testcase = body.root.testcase["name"]
+        get_authorized_user(f"ANY-DATA:{testcase}")
+        return create_result_any_data(body.root)
+
+    api.add_url_rule(
+        "/results",
+        endpoint="results",
+        methods=["POST"],
+        view_func=create,
+    )
+
+
+def create_endpoints(oidc, provider):
+    for params_class in RESULTS_PARAMS_CLASSES:
+        create_endpoint(params_class, oidc, provider)
+
+    create_any_data_endpoint(oidc, provider)
+
+
+@api.route("/permissions")
+@validate()
+def get_permissions(query: PermissionsParams):
+    if query.testcase:
+        return list(match_testcase_permissions(query.testcase, permissions()))
+
+    return permissions()
+
+
+@api.route("/")
+def index():
+    examples = [params_class.example() for params_class in RESULTS_PARAMS_CLASSES]
+    endpoints = [
+        {
+            "name": f"results/{example.artifact_type()}s",
+            "method": "POST",
+            "description": example.__doc__,
+            "query_type": "JSON",
+            "example": example.model_dump_json(exclude_unset=True, indent=2),
+            "schema": example.model_json_schema(),
+            "schema_endpoint": f".schemas_{example.artifact_type()}s",
+        }
+        for example in examples
+    ]
+    endpoints.append(
+        {
+            "name": "permissions",
+            "method": "GET",
+            "description": PermissionsParams.__doc__,
+            "query_type": "Query",
+            "schema": PermissionsParams.model_construct().model_json_schema(),
+        }
+    )
+    return render_template(
+        "api_v3.html",
+        endpoints=endpoints,
+        result_outcomes_extended=", ".join(result_outcomes_extended()),
+    )

data/resultsdb/controllers/common.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: GPL-2.0+
+from flask import current_app as app
+from flask import jsonify
+
+from resultsdb.messaging import create_message, publish_taskotron_message
+from resultsdb.models import db
+from resultsdb.serializers.api_v2 import Serializer
+
+SERIALIZE = Serializer().serialize
+
+
+def commit_result(result):
+    """
+    Saves result in database and publishes message.
+
+    Returns value for the POST HTTP API response.
+    """
+    db.session.add(result)
+    db.session.commit()
+
+    app.logger.debug(
+        "Created new result for testcase %s with outcome %s",
+        result.testcase.name,
+        result.outcome,
+    )
+
+    if app.messaging_plugin:
+        app.logger.debug("Preparing to publish message for result id %d", result.id)
+        message = create_message(result)
+        app.messaging_plugin.publish(message)
+
+    if app.config["MESSAGE_BUS_PUBLISH_TASKOTRON"]:
+        app.logger.debug(
+            "Preparing to publish Taskotron message for result id %d", result.id
+        )
+        publish_taskotron_message(result)
+
+    return jsonify(SERIALIZE(result)), 201

data/resultsdb/controllers/main.py

@@ -0,0 +1,28 @@
+# Copyright 2013, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Josef Skladanka <[email protected]>
+
+from flask import Blueprint, render_template
+
+main = Blueprint("main", __name__)
+
+
+@main.route("/")
+@main.route("/index")
+def index():
+    return render_template("index.html")

data/resultsdb/messaging.py

@@ -0,0 +1,271 @@
+# Copyright 2016, Red Hat, Inc
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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 General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors:
+#   Ralph Bean <[email protected]>
+
+import abc
+import json
+import logging
+from threading import Lock
+
+import pkg_resources
+import stomp
+from fedora_messaging.api import Message, publish
+from fedora_messaging.exceptions import (
+    ConnectionException,
+    PublishForbidden,
+    PublishReturned,
+    PublishTimeout,
+)
+from opentelemetry import trace
+from opentelemetry.trace.propagation.tracecontext import (
+    TraceContextTextMapPropagator,
+)
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from resultsdb.models import db
+from resultsdb.models.results import Result, ResultData
+from resultsdb.serializers.api_v2 import Serializer
+
+log = logging.getLogger(__name__)
+tracer = trace.get_tracer(__name__)
+
+SERIALIZE = Serializer().serialize
+
+STOMP_RETRY_STOP = stop_after_attempt(3)
+STOMP_RETRY_WAIT = wait_exponential(multiplier=2, min=5, max=15)
+
+
+def get_prev_result(result):
+    """
+    Find previous result with the same testcase, item, type, and arch.
+    Return None if no result is found.
+
+    Note that this logic is Taskotron-specific: it does not consider the
+    possibility that a result may be distinguished by other keys in the data
+    (for example 'scenario' which is used in OpenQA results). But this is only
+    used for publishing Taskotron compatibility messages, thus we keep this
+    logic as is.
+    """
+    q = db.session.query(Result).filter(Result.id != result.id)
+    q = q.filter_by(testcase_name=result.testcase_name)
+
+    for result_data in result.data:
+        if result_data.key in ["item", "type", "arch"]:
+            alias = db.aliased(ResultData)
+            q = q.join(alias).filter(
+                db.and_(alias.key == result_data.key, alias.value == result_data.value)
+            )
+
+    q = q.order_by(db.desc(Result.submit_time))
+    return q.first()
+
+
+def publish_taskotron_message(result):
+    """
+    Publish a fedmsg on the taskotron topic with Taskotron-compatible structure.
+
+    These messages are deprecated, consumers should consume from the resultsdb
+    topic instead.
+    """
+    prev_result = get_prev_result(result)
+    if prev_result is not None and prev_result.outcome == result.outcome:
+        # If the previous result had the same outcome, skip publishing
+        # a message for this new result.
+        # This was intended as a workaround to avoid spammy messages from the
+        # dist.depcheck task, which tends to produce a very large number of
+        # identical results for any given build, because of the way that it is
+        # designed.
+        log.debug(
+            "Skipping Taskotron message for result %d, outcome has not changed",
+            result.id,
+        )
+        return
+
+    task = {
+        datum.key: datum.value
+        for datum in result.data
+        if datum.key
+        in (
+            "item",
+            "type",
+        )
+    }
+    task["name"] = result.testcase.name
+    body = {
+        "task": task,
+        "result": {
+            "id": result.id,
+            "submit_time": result.submit_time.strftime("%Y-%m-%d %H:%M:%S UTC"),
+            "prev_outcome": prev_result.outcome if prev_result else None,
+            "outcome": result.outcome,
+            "log_url": result.ref_url,
+        },
+    }
+
+    try:
+        msg = Message(topic="taskotron.result.new", body=body)
+        publish(msg)
+        log.debug("Message published")
+    except PublishReturned as e:
+        log.error(f"Fedora Messaging broker rejected message {msg.id}: {e}")
+    except PublishTimeout:
+        log.error(f"Timeout publishing message {msg.id}")
+    except PublishForbidden as e:
+        log.error(f"Permission error publishing message {msg.id}: {e}")
+    except ConnectionException as e:
+        log.error(f"Error sending message {msg.id}: {e.reason}")
+
+
+def create_message(result):
+    # Re-use the same structure as in the HTTP API v2.
+    return SERIALIZE(result)
+
+
+class MessagingPlugin:
+    """Abstract base class that messaging plugins must extend.
+
+    One abstract method is declared which must be implemented:
+        - publish(message)
+
+    """
+
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @abc.abstractmethod
+    def publish(self, message):
+        pass
+
+
+class DummyPlugin(MessagingPlugin):
+    """A dummy plugin used for testing.  Just logs the messages."""
+
+    # A class attribute where we store all messages published.
+    # Used by the test suite.  This would cause a memory leak if used in prod.
+    history: list[dict[str, object]] = []
+
+    def publish(self, message):
+        # Add telemetry information. This includes an extra key
+        # traceparent.
+        TraceContextTextMapPropagator().inject(message)
+        self.history.append(message)
+        log.info(f"{self!r}->{message!r}")
+
+
+class FedmsgPlugin(MessagingPlugin):
+    """A fedmsg plugin, used to publish to the fedmsg bus."""
+
+    def publish(self, message):
+        try:
+            msg = Message(topic=f"{self.modname}.result.new", body=message)
+            publish(msg)
+            log.debug("Message published")
+        except PublishReturned as e:
+            log.error(f"Fedora Messaging broker rejected message {msg.id}: {e}")
+        except PublishTimeout:
+            log.error(f"Timeout publishing message {msg.id}")
+        except PublishForbidden as e:
+            log.error(f"Permission error publishing message {msg.id}: {e}")
+        except ConnectionException as e:
+            log.error(f"Error sending message {msg.id}: {e.reason}")
+
+
+class StompPlugin(MessagingPlugin):
+    def __init__(self, **kwargs):
+        args = kwargs.copy()
+        conn_args = args["connection"].copy()
+        if "use_ssl" in conn_args:
+            use_ssl = conn_args["use_ssl"]
+            del conn_args["use_ssl"]
+        else:
+            use_ssl = False
+
+        ssl_args = {"for_hosts": conn_args.get("host_and_ports", [])}
+        for attr in ("key_file", "cert_file", "ca_certs"):
+            conn_attr = f"ssl_{attr}"
+            if conn_attr in conn_args:
+                ssl_args[attr] = conn_args[conn_attr]
+                del conn_args[conn_attr]
+
+        if "ssl_version" in conn_args:
+            ssl_args["ssl_version"] = conn_args["ssl_version"]
+            del conn_args["ssl_version"]
+
+        args["connection"] = conn_args
+        args["use_ssl"] = use_ssl
+        args["ssl_args"] = ssl_args
+
+        super().__init__(**args)
+
+        # Validate that some required config is present
+        required = ["connection", "destination"]
+        for attr in required:
+            if getattr(self, attr, None) is None:
+                raise ValueError(f"Missing {attr!r} option for STOMP messaging plugin")
+
+        self.conn_lock = Lock()
+        self.conn = stomp.connect.StompConnection11(**self.connection)
+        if self.use_ssl:
+            self.conn.set_ssl(**self.ssl_args)
+
+    @tracer.start_as_current_span("StompPlugin.publish")
+    def publish(self, msg):
+        # Add telemetry information. This includes an extra key
+        # traceparent.
+        TraceContextTextMapPropagator().inject(msg)
+
+        msg = json.dumps(msg)
+        kwargs = {"body": msg, "headers": {}, "destination": self.destination}
+        self._publish_with_retry(**kwargs)
+
+    @retry(stop=STOMP_RETRY_STOP, wait=STOMP_RETRY_WAIT, reraise=True)
+    def _publish_with_retry(self, **kwargs):
+        with self.conn_lock:
+            if not self.conn.is_connected():
+                log.info("Connecting to message bus")
+
+                # Inactive connection is be closed/disconnected automatically
+                # after a short time.
+                with tracer.start_as_current_span("StompPlugin.publish.connect"):
+                    self.conn.connect(wait=True)
+            with tracer.start_as_current_span("StompPlugin.publish.send"):
+                self.conn.send(**kwargs)
+            log.debug("Published message through stomp: %s", kwargs["body"])
+
+
+def load_messaging_plugin(name, plugin_args):
+    """Instantiate and return the appropriate messaging plugin."""
+    points = pkg_resources.iter_entry_points("resultsdb.messaging.plugins")
+    classes = {"dummy": DummyPlugin}
+    classes.update({point.name: point.load() for point in points})
+
+    log.debug("Found the following installed messaging plugin %r" % classes)
+    if name not in classes:
+        raise KeyError(f"{name!r} not found in {classes.keys()!r}")
+
+    cls = classes[name]
+
+    # Sanity check
+    if not issubclass(cls, MessagingPlugin):
+        raise TypeError(f"{name} {cls!r} does not extend MessagingPlugin.")
+
+    log.debug(f"Instantiating plugin {cls!r} named {name}")
+    return cls(**plugin_args)