Persist run info

conbench/api/__init__.py

@@ -12,4 +12,5 @@
 from .contexts import *
 from .index import *
 from .machines import *
+from .runs import *
 from .users import *

conbench/api/_docs.py

@@ -69,6 +69,7 @@ def _201_created(example, schema=None):
 spec.components.response("CompareList", _200_ok(ex.COMPARE_LIST))
 spec.components.response("ContextEntity", _200_ok(ex.CONTEXT_ENTITY))
 spec.components.response("MachineEntity", _200_ok(ex.MACHINE_ENTITY))
+spec.components.response("RunEntity", _200_ok(ex.RUN_ENTITY))
 spec.components.response("UserEntity", _200_ok(ex.USER_ENTITY))
 spec.components.response("UserList", _200_ok(ex.USER_LIST))
 spec.components.response("UserCreated", _201_created(ex.USER_ENTITY))
@@ -82,6 +83,7 @@ def _201_created(example, schema=None):
     {"name": "Compare", "description": "Compare benchmarks"},
     {"name": "Contexts", "description": "Benchmark contexts"},
     {"name": "Machines", "description": "Benchmark machines"},
+    {"name": "Runs", "description": "Benchmark runs"},
     {"name": "Ping", "description": "Monitor status"},
 ]
 

conbench/api/_examples.py

@@ -200,6 +200,16 @@ def _api_machine_entity(machine_id):
     }
 
 
+def _api_run_entity(run_id, machine_id):
+    return {
+        "id": run_id,
+        "links": {
+            "self": "http://localhost/api/runs/%s/" % run_id,
+            "machine": "http://localhost/api/machines/%s/" % machine_id,
+        },
+    }
+
+
 BENCHMARK_ENTITY = _api_benchmark_entity(
     "some-benchmark-uuid-1",
     "some-machine-uuid-1",
@@ -249,6 +259,7 @@ def _api_machine_entity(machine_id):
 )
 CONTEXT_ENTITY = _api_context_entity("some-context-uuid-1")
 MACHINE_ENTITY = _api_machine_entity("some-machine-uuid-1")
+RUN_ENTITY = _api_run_entity("some-run-uuid-1", "some-machine-uuid-1")
 USER_ENTITY = _api_user_entity(FakeUser1())
 USER_LIST = [
     _api_user_entity(FakeUser1()),

conbench/api/runs.py

@@ -0,0 +1,43 @@
+from ..api import rule
+from ..api._endpoint import ApiEndpoint
+from ..entities._entity import NotFound
+from ..entities.run import Run, RunSerializer
+
+
+class RunEntityAPI(ApiEndpoint):
+    serializer = RunSerializer()
+
+    def _get(self, run_id):
+        try:
+            run = Run.one(id=run_id)
+        except NotFound:
+            self.abort_404_not_found()
+        return run
+
+    def get(self, run_id):
+        """
+        ---
+        description: Get a run.
+        responses:
+            "200": "RunEntity"
+            "401": "401"
+            "404": "404"
+        parameters:
+          - name: run_id
+            in: path
+            schema:
+                type: string
+        tags:
+          - Runs
+        """
+        run = self._get(run_id)
+        return self.serializer.one.dump(run)
+
+
+run_entity_view = RunEntityAPI.as_view("run")
+
+rule(
+    "/runs/<run_id>/",
+    view_func=run_entity_view,
+    methods=["GET"],
+)

conbench/entities/run.py

@@ -1,12 +1,34 @@
+import flask as f
 import sqlalchemy as s
 from sqlalchemy.orm import relationship
 
-from ..entities._entity import Base, EntityMixin, NotNull
+from ..entities._entity import Base, EntityMixin, EntitySerializer, NotNull
 
 
 class Run(Base, EntityMixin):
     __tablename__ = "run"
     id = NotNull(s.String(50), primary_key=True)
     timestamp = NotNull(s.DateTime(timezone=False), server_default=s.sql.func.now())
     github_id = NotNull(s.String(50), s.ForeignKey("github.id"))
-    github = relationship("GitHub", lazy="joined")
+    github = relationship("GitHub", lazy="select")
+    machine_id = NotNull(s.String(50), s.ForeignKey("machine.id"))
+    machine = relationship("Machine", lazy="select")
+
+
+class _Serializer(EntitySerializer):
+    def _dump(self, run):
+        result = {
+            "id": run.id,
+            "links": {
+                "self": f.url_for("api.run", run_id=run.id, _external=True),
+                "machine": f.url_for(
+                    "api.machine", machine_id=run.machine_id, _external=True
+                ),
+            },
+        }
+        return result
+
+
+class RunSerializer:
+    one = _Serializer()
+    many = _Serializer(many=True)

conbench/entities/summary.py

@@ -107,7 +107,13 @@ def create(data):
         run_id = data["stats"]["run_id"]
         run = Run.first(id=run_id)
         if not run:
-            run = Run.create({"id": run_id, "github_id": github.id})
+            run = Run.create(
+                {
+                    "id": run_id,
+                    "github_id": github.id,
+                    "machine_id": machine.id,
+                }
+            )
 
         stats = data["stats"]
         values = stats.pop("data")

conbench/tests/api/_expected_docs.py

@@ -454,6 +454,20 @@
                 },
                 "description": "OK",
             },
+            "RunEntity": {
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "id": "some-run-uuid-1",
+                            "links": {
+                                "machine": "http://localhost/api/machines/some-machine-uuid-1/",
+                                "self": "http://localhost/api/runs/some-run-uuid-1/",
+                            },
+                        }
+                    }
+                },
+                "description": "OK",
+            },
             "UserCreated": {
                 "content": {
                     "application/json": {
@@ -909,6 +923,25 @@
                 "tags": ["Authentication"],
             }
         },
+        "/api/runs/{run_id}/": {
+            "get": {
+                "description": "Get a run.",
+                "parameters": [
+                    {
+                        "in": "path",
+                        "name": "run_id",
+                        "required": True,
+                        "schema": {"type": "string"},
+                    }
+                ],
+                "responses": {
+                    "200": {"$ref": "#/components/responses/RunEntity"},
+                    "401": {"$ref": "#/components/responses/401"},
+                    "404": {"$ref": "#/components/responses/404"},
+                },
+                "tags": ["Runs"],
+            }
+        },
         "/api/users/": {
             "get": {
                 "description": "Get a list of users.",
@@ -1005,6 +1038,7 @@
         {"description": "Compare benchmarks", "name": "Compare"},
         {"description": "Benchmark contexts", "name": "Contexts"},
         {"description": "Benchmark machines", "name": "Machines"},
+        {"description": "Benchmark runs", "name": "Runs"},
         {"description": "Monitor status", "name": "Ping"},
     ],
 }

conbench/tests/api/test_runs.py

@@ -0,0 +1,31 @@
+import copy
+
+from ...api._examples import _api_run_entity
+from ...entities.summary import Summary
+from ...tests.api import _asserts
+from ...tests.api.test_benchmarks import VALID_PAYLOAD
+
+
+def _expected_entity(run):
+    return _api_run_entity(run.id, run.machine_id)
+
+
+def create_benchmark_summary():
+    data = copy.deepcopy(VALID_PAYLOAD)
+    summary = Summary.create(data)
+    return summary
+
+
+class TestRunGet(_asserts.GetEnforcer):
+    url = "/api/runs/{}/"
+    public = True
+
+    def _create(self):
+        summary = create_benchmark_summary()
+        return summary.run
+
+    def test_get_run(self, client):
+        self.authenticate(client)
+        run = self._create()
+        response = client.get(f"/api/runs/{run.id}/")
+        self.assert_200_ok(response, _expected_entity(run))