Issue 4354, 4355 - handle dirty/outdated repos on release

releaseAutomation.py

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from __future__ import print_function
 
 import os
 import re
 import codecs
 import subprocess
 import tarfile
 import json
-
-from itertools import groupby
 
 from packager import readMetadata, getDefaultFileName
 
 
 def get_dependencies(prefix, repos):
     from ensure_dependencies import read_deps, safe_join
     repo = repos[prefix]
     deps = read_deps(repo)
     if deps:
         for subpath in deps:
@@ skipping 17 matching lines @@
                         if os.path.basename(fileinfo.name) in ('.hgtags', '.hgignore'):
                             continue
                         filedata = repoarchive.extractfile(fileinfo)
                         fileinfo.name = re.sub(r'^[^/]+/', prefix, fileinfo.name)
                         archive.addfile(fileinfo, filedata)
             finally:
                 process.stdout.close()
                 process.wait()
 
 
-def repo_has_uncommitted(aborts_process=True):
+def repo_has_uncommitted():
     """Checks if the given repository is clean"""
-    uncommitted = False
-    status_mapping = {
-        'M': 'modified',
-        'A': 'added',
-        'R': 'removed',
-        '!': 'missing',
-        '?': 'untracked',
-    }
+    buff = subprocess.check_output(['hg', 'status'])
 
-    # Check for any uncommitted changes
-    buff = subprocess.check_output(['hg', 'status'])
     if len(buff):
-        uncommitted = True
-        dirty_files = buff.strip().split(os.linesep)
         print('Dirty / uncommitted changes in repository!')
-        grouped_dirty = groupby(dirty_files, key=lambda x: x.split(' ')[0])
-        for dirty_grp in grouped_dirty:
-            print('{}:'.format(status_mapping[dirty_grp[0]]))
-            for dirty in dirty_grp[1]:
-                print('  {}'.format(dirty.split(' ')[1]))
+        return True
 
-    return uncommitted, aborts_process
+    return False
 
 
-def repo_has_outgoing(path, aborts_process=False):
+def repo_has_outgoing():
     """Checks whether there would be outgoing changesets to the given path"""
     try:
-        buff = subprocess.check_output(['hg', 'outgoing', path])
-        print('Detected outgoing changesets:')
-        print(buff)
-        return True, aborts_process
-    except subprocess.CalledProcessError:
-        return False, aborts_process
+        subprocess.check_output(['hg', 'outgoing'])
+        print('Detected outgoing changesets!')
+        return True
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 1:
+            return False
+        raise
 
 
-def repo_has_incoming(repo_paths, aborts_process=True):
+def repo_has_incoming(*repo_paths):
     """Checks whether the local repositories are up-to-date"""
     incoming = False
 
     for repo_path in repo_paths:
         try:
-            buff = subprocess.check_output(['hg', 'incoming', '-R', repo_path])
-            print('Detected incoming changesets:')
-            print(buff)
+            subprocess.check_output(['hg', 'incoming', '-R', repo_path])
+            print('Detected incoming changesets in "{}"'.format(repo_path))
             incoming = True
-        except subprocess.CalledProcessError:
-            pass
+        except subprocess.CalledProcessError as e:
+            if e.returncode != 1:
+                raise
 
-    return incoming, aborts_process
+    return incoming
 
 
-def ask_to_continue():
-    """Asks the user if he wants to continue despite facing warnings"""
-    try:
-        input = raw_input
-    except NameError:
-        pass
+def continue_with_outgoing():
+    """Asks the user if they want to continue despite facing warnings"""
 
-    print('The above error/s has/have been detected within the repositories.')
-    print('You might want to check whether this is ok or not.')
-    print('Are you sure about continuing the release-process?')
+    print('If you proceed with the release, they will be included in the '
+          'release and pushed.')
+    print('Are you sure about continuing the release process?')
+
     while True:
-        choice = input('Please choose (yes / no): ')
-        if choice.lower() not in ('yes', 'no'):
-            print('Please answer "yes" or "no"!')
-        else:
-            break
+        choice = raw_input('Please choose (yes / no): ').lower().strip()
 
-    return choice.lower() == 'yes'
+        if choice == 'yes':
+            return True
+        if choice == 'no':
+            return False
 
 
-def run(baseDir, type, version, keyFile, downloadsRepo, path='default'):
-    # run repository-checks and bail out early, in case the user does not
-    # explicitly want to continue OR if the check would cause the process to
-    # abort anyway
-    repo_checks = (
-        (repo_has_uncommitted, ()),
-        (repo_has_outgoing, (path,)),
-        (repo_has_incoming, ((baseDir, downloadsRepo),)),
-    )
+def can_safely_release(*repo_paths):
+    """Run repository-checks in order to bail out early if necessary"""
+    if repo_has_uncommitted():
+        return False
+    if repo_has_incoming(*repo_paths):
+        return False
+    if repo_has_outgoing():
+        return continue_with_outgoing()
 
-    check_results = [func(*args) for func, args in repo_checks]
 
-    if (
-            any(check and aborts for check, aborts in check_results)
-            or (
-                any(check and not aborts for check, aborts in check_results)
-                and not ask_to_continue()
-            )):
+def run(baseDir, type, version, keyFile, downloadsRepo):
+    if not can_safely_release(baseDir, downloadsRepo):
         print('Aborting release.')
         return 1
 
     if type == 'gecko':
         import buildtools.packagerGecko as packager
     elif type == 'safari':
         import buildtools.packagerSafari as packager
     elif type == 'edge':
         import buildtools.packagerEdge as packager
     elif type == 'chrome':
@@ skipping 60 matching lines @@
     create_sourcearchive(baseDir, archivePath)
     downloads.append(archivePath)
 
     # Now add the downloads and commit
     subprocess.check_call(['hg', 'add', '-R', downloadsRepo] + downloads)
     subprocess.check_call(['hg', 'commit', '-R', downloadsRepo, '-m', 'Releasing %s %s' % (extensionName, version)])
 
     # Push all changes
     subprocess.check_call(['hg', 'push', '-R', baseDir])
     subprocess.check_call(['hg', 'push', '-R', downloadsRepo])