chore: release 1.1.3 (#2780)

Author: mohammad-alisafaee

.github/workflows/test_deploy.yml

@@ -853,7 +853,7 @@ jobs:
           ref: 'develop'
       - name: merge changes from master
         run: |
-          git merge master
+          git merge origin/master --message "Merge branch 'master' into develop"
           git push
 
   build-images:
@@ -876,8 +876,8 @@ jobs:
         if: "startsWith(github.ref, 'refs/tags/') || endsWith(github.ref, github.event.repository.default_branch)"
         uses: Azure/docker-login@v1
         with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
+          username: ${{ secrets.RENKU_DOCKER_USERNAME }}
+          password: ${{ secrets.RENKU_DOCKER_PASSWORD }}
       - name: push images
         if: "startsWith(github.ref, 'refs/tags/') ||  endsWith(github.ref, github.event.repository.default_branch)"
         run: |
@@ -909,8 +909,8 @@ jobs:
         env:
           CHART_NAME: renku-core
           GITHUB_TOKEN: ${{ secrets.RENKUBOT_GITHUB_TOKEN }}
-          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+          DOCKER_USERNAME: ${{ secrets.RENKU_DOCKER_USERNAME }}
+          DOCKER_PASSWORD: ${{ secrets.RENKU_DOCKER_PASSWORD }}
       - name: Wait for chart to be available
         run: sleep 120
       - name: Update component version

CHANGES.rst

@@ -18,6 +18,17 @@
 Changes
 =======
 
+`1.1.3 <https://github.com/SwissDataScienceCenter/renku-python/compare/v1.1.2...v1.1.3>`__ (2022-03-25)
+-------------------------------------------------------------------------------------------------------
+
+This is a bugfix release fixing an issue with template update check.
+
+Bug Fixes
+~~~~~~~~~
+
+-  **core:** use consistent template versioning for embedded and remote templates
+   (`#2763 <https://github.com/SwissDataScienceCenter/renku-python/pull/2763>`__)
+
 `1.1.2 <https://github.com/SwissDataScienceCenter/renku-python/compare/v1.1.1...v1.1.2>`__ (2022-03-18)
 -------------------------------------------------------------------------------------------------------
 

Makefile

@@ -22,7 +22,7 @@ DOCKER_PREFIX:=${DOCKER_REGISTRY}$(DOCKER_REPOSITORY)
 GIT_MASTER_HEAD_SHA:=$(shell git rev-parse --short --verify HEAD)
 
 TEMPLATE_URL:=https://github.com/SwissDataScienceCenter/renku-project-template
-TEMPLATE_REFERENCE:=0.3.0
+TEMPLATE_REFERENCE:=$(shell sed -n -E 's/^__template_version__ = "([^"]+)"/\1/p' renku/version.py)
 TEMPLATE_DIR:=renku/templates/
 
 .PHONY: service cli docker-tag docker-push docker-login
@@ -47,6 +47,7 @@ cli:
 	docker build -f Dockerfile.cli -t $(DOCKER_PREFIX)renku-python:`git rev-parse --short HEAD` --build-arg CLEAN_INSTALL=1 .
 
 download-templates:
+	@[ "${TEMPLATE_REFERENCE}" ] || ( echo "__template_version__ is not set"; exit 1 )
 	@echo "Downloading templates"
 	rm -rf $(TEMPLATE_DIR)
 	mkdir -p $(TEMPLATE_DIR)

helm-chart/renku-core/Chart.yaml

@@ -3,4 +3,4 @@ appVersion: "1.0"
 description: A Helm chart for Kubernetes
 name: renku-core
 icon: https://avatars0.githubusercontent.com/u/53332360?s=400&u=a4311d22842343604ef61a8c8a1e5793209a67e9&v=4
-version: 1.1.2
+version: 1.1.3

helm-chart/renku-core/values.yaml

@@ -109,7 +109,7 @@ versions:
     fullnameOverride: ""
     image:
       repository: renku/renku-core
-      tag: "v1.1.2"
+      tag: "v1.1.3"
       pullPolicy: IfNotPresent
   v8:
     name: v8

renku/__init__.py

@@ -19,6 +19,6 @@
 
 from __future__ import absolute_import, print_function
 
-from renku.version import __version__
+from renku.version import __template_version__, __version__
 
-__all__ = ("__version__",)
+__all__ = ("__template_version__", "__version__")

renku/core/commands/view_model/template.py

@@ -66,7 +66,7 @@ def from_template(cls, template: Template) -> "TemplateViewModel":
             parameters=template.parameters,
             icon=template.icon,
             immutable_files=template.immutable_files,
-            versions=template.get_all_versions(),
+            versions=template.get_all_references(),
         )
 
 

renku/core/management/template/template.py

@@ -354,48 +354,42 @@ def read_valid_value(var: TemplateParameter, default_value=None):
 class EmbeddedTemplates(TemplatesSource):
     """Represent templates that are bundled with Renku.
 
-    For embedded templates, ``source`` is "renku" and ``version`` is set to the installed Renku version. ``reference``
-    should not be set for such projects.
+    For embedded templates, ``source`` is "renku". In the old versioning scheme, ``version`` is set to the installed
+    Renku version and ``reference`` is not set. In the new scheme, both ``version`` and ``reference`` are set to the
+    template version.
     """
 
     @classmethod
     def fetch(cls, source: Optional[str], reference: Optional[str]) -> "EmbeddedTemplates":
         """Fetch embedded Renku templates."""
-        from renku import __version__
-
-        if reference and reference != "master":
-            raise errors.ParameterError("Templates included in renku don't support specifying a template reference")
+        from renku import __template_version__
 
         path = importlib_resources.files("renku") / "templates"
         with importlib_resources.as_file(path) as folder:
             path = Path(folder)
 
-        return cls(path=path, source="renku", reference=None, version=str(__version__))
-
-    def is_update_available(self, id: str, reference: Optional[str], version: Optional[str]) -> Tuple[bool, str]:
-        """Return True if an update is available along with the latest version of a template."""
-        latest_version = self.get_latest_version(id=id, reference=reference, version=version)
-        update_available = latest_version is not None and latest_version != version
-
-        return update_available, latest_version
+        return cls(path=path, source="renku", reference=__template_version__, version=__template_version__)
 
-    def get_all_versions(self, id) -> List[str]:
-        """Return all available versions for a template id."""
+    def get_all_references(self, id) -> List[str]:
+        """Return all available references for a template id."""
         template_exists = any(t.id == id for t in self.templates)
-        return [self.version] if template_exists else []
+        return [self.reference] if template_exists else []
 
-    def get_latest_version(self, id: str, reference: Optional[str], version: Optional[str]) -> Optional[str]:
-        """Return latest version number of a template."""
+    def get_latest_reference_and_version(
+        self, id: str, reference: Optional[str], version: Optional[str]
+    ) -> Optional[Tuple[str, str]]:
+        """Return latest reference and version number of a template."""
         if version is None:
             return
+        elif reference is None or reference != version:  # Old versioning scheme
+            return self.reference, self.version
 
-        template_version = Version(self.version)
         try:
             current_version = Version(version)
         except ValueError:  # NOTE: version is not a valid SemVer
-            return str(template_version)
+            return self.reference, self.version
         else:
-            return str(template_version) if current_version < template_version else version
+            return (self.reference, self.version) if current_version < Version(self.version) else (reference, version)
 
     def get_template(self, id, reference: Optional[str]) -> Optional["Template"]:
         """Return all available versions for a template id."""
@@ -432,14 +426,7 @@ def fetch(cls, source: Optional[str], reference: Optional[str]) -> "RepositoryTe
 
         return cls(path=path, source=source, reference=reference, version=version, repository=repository)
 
-    def is_update_available(self, id: str, reference: Optional[str], version: Optional[str]) -> Tuple[bool, str]:
-        """Return True if an update is available along with the latest version of a template."""
-        latest_version = self.get_latest_version(id=id, reference=reference, version=version)
-        update_available = latest_version is not None and latest_version != reference
-
-        return update_available, latest_version
-
-    def get_all_versions(self, id) -> List[str]:
+    def get_all_references(self, id) -> List[str]:
         """Return a list of git tags that are valid SemVer and include a template id."""
         versions = []
         for tag in self.repository.tags:
@@ -454,20 +441,22 @@ def get_all_versions(self, id) -> List[str]:
 
         return [str(v) for v in sorted(versions)]
 
-    def get_latest_version(self, id: str, reference: Optional[str], version: Optional[str]) -> Optional[str]:
-        """Return latest version number of a template."""
+    def get_latest_reference_and_version(
+        self, id: str, reference: Optional[str], version: Optional[str]
+    ) -> Optional[Tuple[str, str]]:
+        """Return latest reference and version number of a template."""
         if version is None:
             return
 
         tag = to_semantic_version(reference)
 
         # NOTE: Assume that a SemVer reference is always a tag
         if tag:
-            versions = self.get_all_versions(id=id)
-            return versions[-1] if len(versions) > 0 else None
+            references = self.get_all_references(id=id)
+            return (references[-1], self.version) if len(references) > 0 else None
 
         # NOTE: Template's reference is a branch or SHA and the latest version is RepositoryTemplates' version
-        return self.version
+        return reference, self.version
 
     def _has_template_at(self, id: str, reference: str) -> bool:
         """Return if template id is available at a reference."""

renku/core/management/template/usecase.py

@@ -70,13 +70,11 @@ def check_for_template_update(client) -> Tuple[bool, bool, Optional[str], Option
     metadata = TemplateMetadata.from_client(client=client)
 
     templates_source = fetch_templates_source(source=metadata.source, reference=metadata.reference)
-    latest_version = templates_source.get_latest_version(
+    update_available, latest_reference = templates_source.is_update_available(
         id=metadata.id, reference=metadata.reference, version=metadata.version
     )
 
-    update_available = latest_version is not None and latest_version != metadata.version
-
-    return update_available, metadata.allow_update, metadata.version, latest_version
+    return update_available, metadata.allow_update, metadata.reference, latest_reference
 
 
 @inject.autoparams("client_dispatcher")
@@ -130,7 +128,7 @@ def update_template(
 
     templates_source = fetch_templates_source(source=template_metadata.source, reference=template_metadata.reference)
 
-    update_available, latest_version = templates_source.is_update_available(
+    update_available, latest_reference = templates_source.is_update_available(
         id=template_metadata.id, reference=template_metadata.reference, version=template_metadata.version
     )
 
@@ -139,7 +137,7 @@ def update_template(
 
     rendered_template, actions = _set_or_update_project_from_template(
         templates_source=templates_source,
-        reference=latest_version,
+        reference=latest_reference,
         id=template_metadata.id,
         interactive=interactive,
         dry_run=dry_run,

renku/core/models/template.py

@@ -60,19 +60,26 @@ def templates(self) -> List["Template"]:
 
         return self.manifest.templates
 
-    @abstractmethod
     def is_update_available(self, id: str, reference: Optional[str], version: Optional[str]) -> Tuple[bool, str]:
-        """Return True if an update is available along with the latest version of a template."""
-        raise NotImplementedError
+        """Return True if an update is available along with the latest reference of a template."""
+        latest = self.get_latest_reference_and_version(id=id, reference=reference, version=version)
+        if not latest:
+            return False, reference
+
+        latest_reference, latest_version = latest
+        update_available = latest_reference != reference or latest_version != version
+        return update_available, latest_reference
 
     @abstractmethod
-    def get_all_versions(self, id) -> List[str]:
+    def get_all_references(self, id) -> List[str]:
         """Return all available versions for a template id."""
         raise NotImplementedError
 
     @abstractmethod
-    def get_latest_version(self, id: str, reference: Optional[str], version: Optional[str]) -> Optional[str]:
-        """Return latest version number of a template."""
+    def get_latest_reference_and_version(
+        self, id: str, reference: Optional[str], version: Optional[str]
+    ) -> Optional[Tuple[str, str]]:
+        """Return latest reference and version number of a template."""
         raise NotImplementedError
 
     @abstractmethod
@@ -220,9 +227,9 @@ def templates_source(self, templates_source: TemplatesSource):
         self.version = templates_source.version
         self.path = templates_source.path / self.id
 
-    def get_all_versions(self) -> List[str]:
-        """Return all available versions for the template."""
-        return self.templates_source.get_all_versions(self.id)
+    def get_all_references(self) -> List[str]:
+        """Return all available references for the template."""
+        return self.templates_source.get_all_references(self.id)
 
     def validate(self, skip_files):
         """Validate a template."""