stable version stuck on a specific commit

readthedocs/projects/exceptions.py

@@ -43,6 +43,10 @@ class RepositoryError(BuildEnvironmentError):
         'One or more submodule URLs are not valid.'
     )
 
+    DUPLICATED_RESERVED_VERSIONS = _(
+        'You can not have two versions with the name latest or stable.'
+    )
+
     def get_default_message(self):
         if settings.ALLOW_PRIVATE_REPOS:
             return self.PRIVATE_ALLOWED

readthedocs/projects/tasks.py

@@ -5,7 +5,8 @@
 rebuilding documentation.
 """
 
-from __future__ import absolute_import
+from __future__ import (
+    absolute_import, division, print_function, unicode_literals)
 
 import datetime
 import hashlib
@@ -14,7 +15,7 @@
 import os
 import shutil
 import socket
-from collections import defaultdict
+from collections import Counter, defaultdict
 
 import requests
 from builtins import str
@@ -31,12 +32,10 @@
 from .exceptions import RepositoryError
 from .models import ImportedFile, Project, Domain
 from .signals import before_vcs, after_vcs, before_build, after_build, files_changed
-from readthedocs.builds.constants import (LATEST,
-                                          BUILD_STATE_CLONING,
-                                          BUILD_STATE_INSTALLING,
-                                          BUILD_STATE_BUILDING,
-                                          BUILD_STATE_FINISHED)
-from readthedocs.builds.models import Build, Version, APIVersion
+from readthedocs.builds.constants import (
+    BUILD_STATE_BUILDING, BUILD_STATE_CLONING, BUILD_STATE_FINISHED,
+    BUILD_STATE_INSTALLING, LATEST, LATEST_VERBOSE_NAME, STABLE_VERBOSE_NAME)
+from readthedocs.builds.models import APIVersion, Build, Version
 from readthedocs.builds.signals import build_complete
 from readthedocs.builds.syncers import Syncer
 from readthedocs.core.resolver import resolve_path
@@ -141,6 +140,8 @@ def sync_repo(self):
                      } for v in version_repo.branches
                 ]
 
+            self.validate_duplicate_reserved_versions(version_post_data)
+
             try:
                 # Hit the API ``sync_versions`` which may trigger a new build
                 # for the stable version
@@ -150,6 +151,27 @@ def sync_repo(self):
             except Exception:
                 log.exception('Unknown Sync Versions Exception')
 
+    def validate_duplicate_reserved_versions(self, data):
+        """
+        Check if there are duplicated names of reserved versions.
+
+        The user can't have a branch and a tag with the same name of
+        ``latest`` or ``stable``. Raise a RepositoryError exception
+        if there is a duplicated name.
+
+        :param data: Dict containing the versions from tags and branches
+        """
+        version_names = [
+            version['verbose_name']
+            for version in data.get('tags', []) + data.get('branches', [])
+        ]
+        counter = Counter(version_names)
+        for reserved_name in [STABLE_VERBOSE_NAME, LATEST_VERBOSE_NAME]:
+            if counter[reserved_name] > 1:
+                raise RepositoryError(
+                    RepositoryError.DUPLICATED_RESERVED_VERSIONS
+                )
+
     # TODO this is duplicated in the classes below, and this should be
     # refactored out anyways, as calling from the method removes the original
     # caller from logging.

readthedocs/restapi/utils.py

@@ -9,7 +9,9 @@
 
 from rest_framework.pagination import PageNumberPagination
 
-from readthedocs.builds.constants import NON_REPOSITORY_VERSIONS
+from readthedocs.builds.constants import (LATEST, LATEST_VERBOSE_NAME,
+                                          NON_REPOSITORY_VERSIONS, STABLE,
+                                          STABLE_VERBOSE_NAME)
 from readthedocs.builds.models import Version
 from readthedocs.search.indexes import PageIndex, ProjectIndex, SectionIndex
 
@@ -18,18 +20,41 @@
 
 def sync_versions(project, versions, type):  # pylint: disable=redefined-builtin
     """Update the database with the current versions from the repository."""
-    old_versions = {}
-    old_version_values = project.versions.filter(type=type).values(
-        'identifier', 'verbose_name')
-    for version in old_version_values:
-        old_versions[version['verbose_name']] = version['identifier']
+    old_version_values = project.versions.filter(type=type).values_list(
+        'verbose_name', 'identifier'
+    )
+    old_versions = dict(old_version_values)
 
-    added = set()
     # Add new versions
+    added = set()
+    has_user_stable = False
+    has_user_latest = False
     for version in versions:
         version_id = version['identifier']
         version_name = version['verbose_name']
-        if version_name in old_versions:
+        if version_name == STABLE_VERBOSE_NAME:
+            has_user_stable = True
+            created_version, created = set_or_create_version(
+                project=project,
+                slug=STABLE,
+                version_id=version_id,
+                verbose_name=version_name,
+                type_=type
+            )
+            if created:
+                added.add(created_version.slug)
+        elif version_name == LATEST_VERBOSE_NAME:
+            has_user_latest = True
+            created_version, created = set_or_create_version(
+                project=project,
+                slug=LATEST,
+                version_id=version_id,
+                verbose_name=version_name,
+                type_=type
+            )
+            if created:
+                added.add(created_version.slug)
+        elif version_name in old_versions:
             if version_id == old_versions[version_name]:
                 # Version is correct
                 continue
@@ -44,23 +69,68 @@ def sync_versions(project, versions, type):  # pylint: disable=redefined-builtin
 
                 log.info(
                     '(Sync Versions) Updated Version: [%s=%s] ',
-                    version['verbose_name'],
-                    version['identifier'],
+                    version_name,
+                    version_id,
                 )
         else:
             # New Version
             created_version = Version.objects.create(
                 project=project,
                 type=type,
-                identifier=version['identifier'],
-                verbose_name=version['verbose_name'],
+                identifier=version_id,
+                verbose_name=version_name,
             )
             added.add(created_version.slug)
+    if not has_user_stable:
+        stable_version = (
+            project.versions
+            .filter(slug=STABLE, type=type)
+            .first()
+        )
+        if stable_version:
+            # Put back the RTD's stable version
+            stable_version.machine = True
+            stable_version.save()
+    if not has_user_latest:
+        latest_version = (
+            project.versions
+            .filter(slug=LATEST, type=type)
+            .first()
+        )
+        if latest_version:
+            # Put back the RTD's latest version
+            latest_version.machine = True
+            latest_version.identifier = project.get_default_branch()
+            latest_version.verbose_name = LATEST_VERBOSE_NAME
+            latest_version.save()
     if added:
         log.info('(Sync Versions) Added Versions: [%s] ', ' '.join(added))
     return added
 
 
+def set_or_create_version(project, slug, version_id, verbose_name, type_):
+    """Search or create a version and set its machine atribute to false."""
+    version = (
+        project.versions
+        .filter(slug=slug)
+        .first()
+    )
+    if version:
+        version.identifier = version_id
+        version.machine = False
+        version.type = type_
+        version.save()
+    else:
+        created_version = Version.objects.create(
+            project=project,
+            type=type_,
+            identifier=version_id,
+            verbose_name=verbose_name,
+        )
+        return created_version, True
+    return version, False
+
+
 def delete_versions(project, version_data):
     """Delete all versions not in the current repo."""
     current_versions = []

readthedocs/rtd_tests/tests/test_celery.py

@@ -1,3 +1,5 @@
+from __future__ import division, print_function, unicode_literals
+
 import os
 import json
 import shutil
@@ -9,14 +11,19 @@
 from mock import patch, MagicMock
 
 from readthedocs.builds.constants import BUILD_STATE_INSTALLING, BUILD_STATE_FINISHED, LATEST
+from readthedocs.projects.exceptions import RepositoryError
 from readthedocs.builds.models import Build
 from readthedocs.projects.models import Project
 from readthedocs.projects import tasks
 
+from readthedocs.rtd_tests.utils import (
+    create_git_branch, create_git_tag, delete_git_branch, delete_git_tag)
 from readthedocs.rtd_tests.utils import make_test_git
 from readthedocs.rtd_tests.base import RTDTestCase
 from readthedocs.rtd_tests.mocks.mock_api import mock_api
 
+from readthedocs.doc_builder.environments import BuildEnvironment
+
 
 class TestCeleryBuilding(RTDTestCase):
 
@@ -124,6 +131,58 @@ def test_sync_repository(self):
             )
         self.assertTrue(result.successful())
 
+    @patch('readthedocs.projects.tasks.api_v2')
+    def test_check_duplicate_reserved_version_latest(self, api_v2):
+        create_git_branch(self.repo, 'latest')
+        create_git_tag(self.repo, 'latest')
+
+        version = self.project.versions.get(slug=LATEST)
+        sync_repository = tasks.UpdateDocsTaskStep()
+        sync_repository.version = version
+        sync_repository.project = self.project
+        with self.assertRaises(RepositoryError) as e:
+            sync_repository.sync_repo()
+        self.assertEqual(
+            str(e.exception),
+            RepositoryError.DUPLICATED_RESERVED_VERSIONS
+        )
+
+        delete_git_branch(self.repo, 'latest')
+        sync_repository.sync_repo()
+        api_v2.project().sync_versions.post.assert_called()
+
+    @patch('readthedocs.projects.tasks.api_v2')
+    def test_check_duplicate_reserved_version_stable(self, api_v2):
+        create_git_branch(self.repo, 'stable')
+        create_git_tag(self.repo, 'stable')
+
+        version = self.project.versions.get(slug=LATEST)
+        sync_repository = tasks.UpdateDocsTaskStep()
+        sync_repository.version = version
+        sync_repository.project = self.project
+        with self.assertRaises(RepositoryError) as e:
+            sync_repository.sync_repo()
+        self.assertEqual(
+            str(e.exception),
+            RepositoryError.DUPLICATED_RESERVED_VERSIONS
+        )
+
+        # TODO: Check that we can build properly after
+        # deleting the tag.
+
+    @patch('readthedocs.projects.tasks.api_v2')
+    def test_check_duplicate_no_reserved_version(self, api_v2):
+        create_git_branch(self.repo, 'no-reserved')
+        create_git_tag(self.repo, 'no-reserved')
+
+        version = self.project.versions.get(slug=LATEST)
+        sync_repository = tasks.UpdateDocsTaskStep()
+        sync_repository.version = version
+        sync_repository.project = self.project
+        sync_repository.sync_repo()
+
+        api_v2.project().sync_versions.post.assert_called()
+
     def test_public_task_exception(self):
         """
         Test when a PublicTask rises an Exception.