feat(service): improve formatting or migrationscheck response

renku/cli/migrate.py

@@ -57,7 +57,6 @@
     check_project,
     migrate_project,
     migrations_check,
-    migrations_versions,
 )
 from renku.core.errors import MigrationRequired, ProjectNotSupported
 
@@ -123,38 +122,8 @@ def migrate(check, no_commit, skip_template_update, skip_docker_update):
 @click.command(hidden=True)
 def migrationscheck():
     """Check status of the project and current renku-python version."""
-    latest_version, project_version = migrations_versions().build().execute().output
-    (
-        migration_required,
-        project_supported,
-        template_update_possible,
-        current_template_version,
-        latest_template_version,
-        template_source,
-        template_ref,
-        template_id,
-        automated_update,
-        docker_update_possible,
-    ) = (migrations_check().lock_project().build().execute().output)
-
-    click.echo(
-        json.dumps(
-            {
-                "latest_version": latest_version,
-                "project_version": project_version,
-                "migration_required": migration_required,
-                "project_supported": project_supported,
-                "template_update_possible": template_update_possible,
-                "current_template_version": str(current_template_version),
-                "latest_template_version": str(latest_template_version),
-                "template_source": template_source,
-                "template_ref": template_ref,
-                "template_id": template_id,
-                "automated_update": automated_update,
-                "docker_update_possible": docker_update_possible,
-            }
-        )
-    )
+    result = migrations_check().lock_project().build().execute().output
+    click.echo(json.dumps(result))
 
 
 @click.command(hidden=True)

renku/core/commands/migrate.py

@@ -19,6 +19,8 @@
 
 from renku.core.incubation.command import Command
 from renku.core.management.migrate import (
+    SUPPORTED_PROJECT_VERSION,
+    _get_project_version,
     is_docker_update_possible,
     is_migration_required,
     is_project_unsupported,
@@ -42,31 +44,69 @@ def migrations_check():
 
 
 def _migrations_check(client):
-    template_update_possible, current_version, new_version = is_template_update_possible(client)
-    return (
-        is_migration_required(client),
-        not is_project_unsupported(client),
-        template_update_possible,
-        current_version,
-        new_version,
-        client.project.template_source,
-        client.project.template_ref,
-        client.project.template_id,
-        bool(client.project.automated_update),
-        is_docker_update_possible(client),
-    )
+    from renku import __version__
+
+    return {
+        "project_supported": not is_project_unsupported(client),
+        "core_renku_version": __version__,
+        "project_renku_version": client.latest_agent,
+        "core_compatibility_status": _metadata_migration_check(client),
+        "dockerfile_renku_status": _dockerfile_migration_check(client),
+        "template_status": _template_migration_check(client),
+    }
+
+
+def template_migration_check():
+    """Return a command for a template migrations check."""
+    return Command().command(_template_migration_check)
+
+
+def _template_migration_check(client):
+    """Return template migration status."""
+    newer_template_available, current_version, new_version = is_template_update_possible(client)
+    return {
+        "automated_template_update": bool(client.project.automated_update),
+        "newer_template_available": newer_template_available,
+        "project_template_version": current_version,
+        "latest_template_version": new_version,
+        "template_source": client.project.template_source,
+        "template_ref": client.project.template_ref,
+        "template_id": client.project.template_id,
+    }
 
 
-def migrations_versions():
-    """Return a command to get source and destination migration versions."""
-    return Command().command(_migrations_versions).lock_project()
+def dockerfile_migration_check():
+    """Return a command for a Dockerfile migrations check."""
+    return Command().command(_dockerfile_migration_check)
 
 
-def _migrations_versions(client):
-    """Return source and destination migration versions."""
+def _dockerfile_migration_check(client):
+    """Return Dockerfile migration status."""
     from renku import __version__
 
-    return __version__, client.latest_agent
+    automated_dockerfile_update, newer_renku_available, dockerfile_renku_version = is_docker_update_possible(client)
+
+    return {
+        "automated_dockerfile_update": automated_dockerfile_update,
+        "newer_renku_available": newer_renku_available,
+        "dockerfile_renku_version": dockerfile_renku_version,
+        "latest_renku_version": __version__,
+    }
+
+
+def metadata_migration_check():
+    """Return a command for a metadata migrations check."""
+    return Command().command(_metadata_migration_check)
+
+
+def _metadata_migration_check(client):
+    """Return metadata migration status."""
+
+    return {
+        "migration_required": is_migration_required(client),
+        "project_metadata_version": _get_project_version(client),
+        "current_metadata_version": SUPPORTED_PROJECT_VERSION,
+    }
 
 
 def migrate_project():
@@ -100,11 +140,11 @@ def _check_project(client):
 
     status = 0
 
-    if is_template_update_possible(client):
+    if is_template_update_possible(client)[0]:
         status |= TEMPLATE_UPDATE_POSSIBLE
     if client.project.automated_update:
         status |= AUTOMATED_TEMPLATE_UPDATE_SUPPORTED
-    if is_docker_update_possible(client):
+    if is_docker_update_possible(client)[0]:
         status |= DOCKERFILE_UPDATE_POSSIBLE
 
     if is_migration_required(client):

renku/core/management/migrate.py

@@ -107,7 +107,7 @@ def migrate(
 
     if not skip_docker_update:
         try:
-            docker_updated = _update_dockerfile(client)
+            docker_updated, _, _ = _update_dockerfile(client)
         except DockerfileUpdateError:
             raise
         except (Exception, BaseException) as e:
@@ -157,13 +157,13 @@ def _update_template(client, check_only=False):
         template_version = pkg_resources.parse_version(template_version)
         current_version = pkg_resources.parse_version(project.template_version)
         if template_version <= current_version:
-            return False, project.template_version, current_version
+            return False, str(project.template_version), str(current_version)
     else:
         if template_version == project.template_version:
-            return False, project.template_version, template_version
+            return False, str(project.template_version), str(template_version)
 
     if check_only:
-        return True, project.template_version, template_version
+        return True, str(project.template_version), str(template_version)
 
     communication.echo("Updating project from template...")
 
@@ -252,15 +252,15 @@ def _update_template(client, check_only=False):
     project.template_version = template_version
     project.to_yaml()
 
-    return True, project.template_version, template_version
+    return True, str(project.template_version), str(template_version)
 
 
 def _update_dockerfile(client, check_only=False):
     """Update the dockerfile to the newest version of renku."""
     from renku import __version__
 
     if not client.docker_path.exists():
-        return False
+        return False, None, None
 
     communication.echo("Updating dockerfile...")
 
@@ -271,18 +271,18 @@ def _update_dockerfile(client, check_only=False):
     m = re.search(r"^ARG RENKU_VERSION=(\d+\.\d+\.\d+)$", dockercontent, flags=re.MULTILINE)
     if not m:
         if check_only:
-            return False
+            return False, None, None
         raise DockerfileUpdateError(
             "Couldn't update renku-python version in Dockerfile, as it doesn't contain an 'ARG RENKU_VERSION=...' line."
         )
 
     docker_version = pkg_resources.parse_version(m.group(1))
 
     if docker_version >= current_version:
-        return False
+        return True, False, str(docker_version)
 
     if check_only:
-        return True
+        return True, True, str(docker_version)
 
     dockercontent = re.sub(
         r"^ARG RENKU_VERSION=\d+\.\d+\.\d+$", f"ARG RENKU_VERSION={__version__}", dockercontent, flags=re.MULTILINE,
@@ -293,7 +293,7 @@ def _update_dockerfile(client, check_only=False):
 
     communication.echo("Updated dockerfile.")
 
-    return True
+    return True, False, str(current_version)
 
 
 def _get_project_version(client):

renku/service/controllers/cache_migrations_check.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 """Renku service migrations check controller."""
 
-from renku.core.commands.migrate import migrations_check, migrations_versions
+from renku.core.commands.migrate import migrations_check
 from renku.service.controllers.api.abstract import ServiceCtrl
 from renku.service.controllers.api.mixins import RenkuOperationMixin
 from renku.service.serializers.cache import ProjectMigrationCheckRequest, ProjectMigrationCheckResponseRPC
@@ -42,37 +42,7 @@ def context(self):
 
     def renku_op(self):
         """Renku operation for the controller."""
-        latest_version, project_version = migrations_versions().build().execute().output
-
-        # TODO: This API design should be improved. Next 2 lines could probably be combined to 1, ie.
-        # return migrations_check().build().execute().output
-        (
-            migration_required,
-            project_supported,
-            template_update_possible,
-            current_template_version,
-            latest_template_version,
-            template_source,
-            template_ref,
-            template_id,
-            automated_update,
-            docker_update_possible,
-        ) = (migrations_check().build().execute().output)
-
-        return {
-            "migration_required": migration_required,
-            "template_update_possible": template_update_possible,
-            "current_template_version": current_template_version,
-            "latest_template_version": latest_template_version,
-            "template_source": template_source,
-            "template_ref": template_ref,
-            "template_id": template_id,
-            "automated_template_update": automated_update,
-            "docker_update_possible": docker_update_possible,
-            "project_supported": project_supported,
-            "project_version": project_version,
-            "latest_version": latest_version,
-        }
+        return migrations_check().build().execute().output
 
     def to_response(self):
         """Execute controller flow and serialize to service response."""

renku/service/controllers/graph_build.py

@@ -50,7 +50,7 @@ def renku_op(self):
         """Renku operation for the controller."""
         result = migrations_check().build().execute().output
 
-        if not result[1]:
+        if not result["project_supported"]:
             raise RenkuException("project not supported")
 
         with enqueue_retry(GRAPH_JOB_QUEUE) as queue:

renku/service/serializers/cache.py

@@ -246,21 +246,46 @@ class ProjectMigrationCheckRequest(Schema):
     branch = fields.String()
 
 
-class ProjectMigrationCheckResponse(Schema):
-    """Response schema for project migration check."""
+class ProjectCompatibilityResponse(Schema):
+    """Response schema outlining service compatibility for migrations check."""
 
+    project_metadata_version = fields.String()
+    current_metadata_version = fields.String()
     migration_required = fields.Boolean()
-    template_update_possible = fields.Boolean()
+
+
+class DockerfileStatusResponse(Schema):
+    """Response schema outlining dockerfile status for migrations check."""
+
+    newer_renku_available = fields.Boolean()
+    automated_dockerfile_update = fields.Boolean()
+    latest_renku_version = fields.String()
+    dockerfile_renku_version = fields.String()
+
+
+class TemplateStatusResponse(Schema):
+    """Response schema outlining template status for migrations check."""
+
     automated_template_update = fields.Boolean()
-    current_template_version = fields.String(allow_none=True)
-    latest_template_version = fields.String(allow_none=True)
+    newer_template_available = fields.Boolean()
     template_source = fields.String()
     template_ref = fields.String()
     template_id = fields.String()
-    docker_update_possible = fields.Boolean()
+
+    project_template_version = fields.String(allow_none=True)
+    latest_template_version = fields.String(allow_none=True)
+
+
+class ProjectMigrationCheckResponse(Schema):
+    """Response schema for project migration check."""
+
     project_supported = fields.Boolean()
-    project_version = fields.String()
-    latest_version = fields.String()
+    core_renku_version = fields.String()
+    project_renku_version = fields.String()
+
+    core_compatibility_status = fields.Nested(ProjectCompatibilityResponse)
+    dockerfile_renku_status = fields.Nested(DockerfileStatusResponse)
+    template_status = fields.Nested(TemplateStatusResponse)
 
 
 class ProjectMigrationCheckResponseRPC(JsonRPCResponse):

tests/cli/test_migrate.py

@@ -65,18 +65,32 @@ def test_migration_check(isolated_runner, project):
     assert 0 == result.exit_code
     output = json.loads(result.output)
     assert output.keys() == {
-        "latest_version",
-        "project_version",
-        "migration_required",
         "project_supported",
-        "template_update_possible",
-        "current_template_version",
-        "latest_template_version",
+        "core_renku_version",
+        "project_renku_version",
+        "core_compatibility_status",
+        "dockerfile_renku_status",
+        "template_status",
+    }
+    assert output["core_compatibility_status"].keys() == {
+        "project_metadata_version",
+        "current_metadata_version",
+        "migration_required",
+    }
+    assert output["dockerfile_renku_status"].keys() == {
+        "newer_renku_available",
+        "automated_dockerfile_update",
+        "latest_renku_version",
+        "dockerfile_renku_version",
+    }
+    assert output["template_status"].keys() == {
+        "automated_template_update",
+        "newer_template_available",
         "template_source",
+        "project_template_version",
+        "latest_template_version",
         "template_ref",
         "template_id",
-        "automated_update",
-        "docker_update_possible",
     }