packaging: add -python2 to Windows installer filenames

We just taught the Windows installers to produce Python 3 variants
built with PyOxidizer.

Our plan is to publish both Python 2 and Python 3 versions of the
installers for Mercurial 5.4.

This commit teaches the Inno and WiX installers to add an optional
string suffix to the installer name. On Python 2, that suffix is
"-python2." We reserve the existing name for the Python 3 installers,
which we want to make the default.

Differential Revision: https://phab.mercurial-scm.org/D8479

contrib/automation/hgautomation/windows.py

@@ -1,533 +1,533 b''
 # windows.py - Automation specific to Windows
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import datetime
 import os
 import paramiko
 import pathlib
 import re
 import subprocess
 import tempfile
 
 from .pypi import upload as pypi_upload
 from .winrm import run_powershell
 
 
 # PowerShell commands to activate a Visual Studio 2008 environment.
 # This is essentially a port of vcvarsall.bat to PowerShell.
 ACTIVATE_VC9_AMD64 = r'''
 Write-Output "activating Visual Studio 2008 environment for AMD64"
 $root = "$env:LOCALAPPDATA\Programs\Common\Microsoft\Visual C++ for Python\9.0"
 $Env:VCINSTALLDIR = "${root}\VC\"
 $Env:WindowsSdkDir = "${root}\WinSDK\"
 $Env:PATH = "${root}\VC\Bin\amd64;${root}\WinSDK\Bin\x64;${root}\WinSDK\Bin;$Env:PATH"
 $Env:INCLUDE = "${root}\VC\Include;${root}\WinSDK\Include;$Env:PATH"
 $Env:LIB = "${root}\VC\Lib\amd64;${root}\WinSDK\Lib\x64;$Env:LIB"
 $Env:LIBPATH = "${root}\VC\Lib\amd64;${root}\WinSDK\Lib\x64;$Env:LIBPATH"
 '''.lstrip()
 
 ACTIVATE_VC9_X86 = r'''
 Write-Output "activating Visual Studio 2008 environment for x86"
 $root = "$env:LOCALAPPDATA\Programs\Common\Microsoft\Visual C++ for Python\9.0"
 $Env:VCINSTALLDIR = "${root}\VC\"
 $Env:WindowsSdkDir = "${root}\WinSDK\"
 $Env:PATH = "${root}\VC\Bin;${root}\WinSDK\Bin;$Env:PATH"
 $Env:INCLUDE = "${root}\VC\Include;${root}\WinSDK\Include;$Env:INCLUDE"
 $Env:LIB = "${root}\VC\Lib;${root}\WinSDK\Lib;$Env:LIB"
 $Env:LIBPATH = "${root}\VC\lib;${root}\WinSDK\Lib;$Env:LIBPATH"
 '''.lstrip()
 
 HG_PURGE = r'''
 $Env:PATH = "C:\hgdev\venv-bootstrap\Scripts;$Env:PATH"
 Set-Location C:\hgdev\src
 hg.exe --config extensions.purge= purge --all
 if ($LASTEXITCODE -ne 0) {
     throw "process exited non-0: $LASTEXITCODE"
 }
 Write-Output "purged Mercurial repo"
 '''
 
 HG_UPDATE_CLEAN = r'''
 $Env:PATH = "C:\hgdev\venv-bootstrap\Scripts;$Env:PATH"
 Set-Location C:\hgdev\src
 hg.exe --config extensions.purge= purge --all
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 hg.exe update -C {revision}
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 hg.exe log -r .
 Write-Output "updated Mercurial working directory to {revision}"
 '''.lstrip()
 
 BUILD_INNO = r'''
 Set-Location C:\hgdev\src
 $python = "C:\hgdev\python27-{arch}\python.exe"
 C:\hgdev\python37-x64\python.exe contrib\packaging\packaging.py inno --python $python
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 '''.lstrip()
 
 BUILD_WHEEL = r'''
 Set-Location C:\hgdev\src
 C:\hgdev\python{python_version}-{arch}\python.exe -m pip wheel --wheel-dir dist .
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 '''
 
 BUILD_WIX = r'''
 Set-Location C:\hgdev\src
 $python = "C:\hgdev\python27-{arch}\python.exe"
 C:\hgdev\python37-x64\python.exe contrib\packaging\packaging.py wix --python $python {extra_args}
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 '''
 
 RUN_TESTS = r'''
 C:\hgdev\MinGW\msys\1.0\bin\sh.exe --login -c "cd /c/hgdev/src/tests && /c/hgdev/{python_path}/python.exe run-tests.py {test_flags}"
 if ($LASTEXITCODE -ne 0) {{
     throw "process exited non-0: $LASTEXITCODE"
 }}
 '''
 
 WHEEL_FILENAME_PYTHON27_X86 = 'mercurial-{version}-cp27-cp27m-win32.whl'
 WHEEL_FILENAME_PYTHON27_X64 = 'mercurial-{version}-cp27-cp27m-win_amd64.whl'
 WHEEL_FILENAME_PYTHON37_X86 = 'mercurial-{version}-cp37-cp37m-win32.whl'
 WHEEL_FILENAME_PYTHON37_X64 = 'mercurial-{version}-cp37-cp37m-win_amd64.whl'
 WHEEL_FILENAME_PYTHON38_X86 = 'mercurial-{version}-cp38-cp38-win32.whl'
 WHEEL_FILENAME_PYTHON38_X64 = 'mercurial-{version}-cp38-cp38-win_amd64.whl'
 
-X86_EXE_FILENAME = 'Mercurial-{version}.exe'
-X64_EXE_FILENAME = 'Mercurial-{version}-x64.exe'
-X86_MSI_FILENAME = 'mercurial-{version}-x86.msi'
-X64_MSI_FILENAME = 'mercurial-{version}-x64.msi'
+X86_EXE_FILENAME = 'Mercurial-{version}-x86-python2.exe'
+X64_EXE_FILENAME = 'Mercurial-{version}-x64-python2.exe'
+X86_MSI_FILENAME = 'mercurial-{version}-x86-python2.msi'
+X64_MSI_FILENAME = 'mercurial-{version}-x64-python2.msi'
 
 MERCURIAL_SCM_BASE_URL = 'https://mercurial-scm.org/release/windows'
 
 X86_USER_AGENT_PATTERN = '.*Windows.*'
 X64_USER_AGENT_PATTERN = '.*Windows.*(WOW|x)64.*'
 
 X86_EXE_DESCRIPTION = (
     'Mercurial {version} Inno Setup installer - x86 Windows '
     '- does not require admin rights'
 )
 X64_EXE_DESCRIPTION = (
     'Mercurial {version} Inno Setup installer - x64 Windows '
     '- does not require admin rights'
 )
 X86_MSI_DESCRIPTION = (
     'Mercurial {version} MSI installer - x86 Windows ' '- requires admin rights'
 )
 X64_MSI_DESCRIPTION = (
     'Mercurial {version} MSI installer - x64 Windows ' '- requires admin rights'
 )
 
 
 def get_vc_prefix(arch):
     if arch == 'x86':
         return ACTIVATE_VC9_X86
     elif arch == 'x64':
         return ACTIVATE_VC9_AMD64
     else:
         raise ValueError('illegal arch: %s; must be x86 or x64' % arch)
 
 
 def fix_authorized_keys_permissions(winrm_client, path):
     commands = [
         '$ErrorActionPreference = "Stop"',
         'Repair-AuthorizedKeyPermission -FilePath %s -Confirm:$false' % path,
         r'icacls %s /remove:g "NT Service\sshd"' % path,
     ]
 
     run_powershell(winrm_client, '\n'.join(commands))
 
 
 def synchronize_hg(hg_repo: pathlib.Path, revision: str, ec2_instance):
     """Synchronize local Mercurial repo to remote EC2 instance."""
 
     winrm_client = ec2_instance.winrm_client
 
     with tempfile.TemporaryDirectory() as temp_dir:
         temp_dir = pathlib.Path(temp_dir)
 
         ssh_dir = temp_dir / '.ssh'
         ssh_dir.mkdir()
         ssh_dir.chmod(0o0700)
 
         # Generate SSH key to use for communication.
         subprocess.run(
             [
                 'ssh-keygen',
                 '-t',
                 'rsa',
                 '-b',
                 '4096',
                 '-N',
                 '',
                 '-f',
                 str(ssh_dir / 'id_rsa'),
             ],
             check=True,
             capture_output=True,
         )
 
         # Add it to ~/.ssh/authorized_keys on remote.
         # This assumes the file doesn't already exist.
         authorized_keys = r'c:\Users\Administrator\.ssh\authorized_keys'
         winrm_client.execute_cmd(r'mkdir c:\Users\Administrator\.ssh')
         winrm_client.copy(str(ssh_dir / 'id_rsa.pub'), authorized_keys)
         fix_authorized_keys_permissions(winrm_client, authorized_keys)
 
         public_ip = ec2_instance.public_ip_address
 
         ssh_config = temp_dir / '.ssh' / 'config'
 
         with open(ssh_config, 'w', encoding='utf-8') as fh:
             fh.write('Host %s\n' % public_ip)
             fh.write('  User Administrator\n')
             fh.write('  StrictHostKeyChecking no\n')
             fh.write('  UserKnownHostsFile %s\n' % (ssh_dir / 'known_hosts'))
             fh.write('  IdentityFile %s\n' % (ssh_dir / 'id_rsa'))
 
         if not (hg_repo / '.hg').is_dir():
             raise Exception(
                 '%s is not a Mercurial repository; '
                 'synchronization not yet supported' % hg_repo
             )
 
         env = dict(os.environ)
         env['HGPLAIN'] = '1'
         env['HGENCODING'] = 'utf-8'
 
         hg_bin = hg_repo / 'hg'
 
         res = subprocess.run(
             ['python2.7', str(hg_bin), 'log', '-r', revision, '-T', '{node}'],
             cwd=str(hg_repo),
             env=env,
             check=True,
             capture_output=True,
         )
 
         full_revision = res.stdout.decode('ascii')
 
         args = [
             'python2.7',
             hg_bin,
             '--config',
             'ui.ssh=ssh -F %s' % ssh_config,
             '--config',
             'ui.remotecmd=c:/hgdev/venv-bootstrap/Scripts/hg.exe',
             # Also ensure .hgtags changes are present so auto version
             # calculation works.
             'push',
             '-f',
             '-r',
             full_revision,
             '-r',
             'file(.hgtags)',
             'ssh://%s/c:/hgdev/src' % public_ip,
         ]
 
         res = subprocess.run(args, cwd=str(hg_repo), env=env)
 
         # Allow 1 (no-op) to not trigger error.
         if res.returncode not in (0, 1):
             res.check_returncode()
 
         run_powershell(
             winrm_client, HG_UPDATE_CLEAN.format(revision=full_revision)
         )
 
         # TODO detect dirty local working directory and synchronize accordingly.
 
 
 def purge_hg(winrm_client):
     """Purge the Mercurial source repository on an EC2 instance."""
     run_powershell(winrm_client, HG_PURGE)
 
 
 def find_latest_dist(winrm_client, pattern):
     """Find path to newest file in dist/ directory matching a pattern."""
 
     res = winrm_client.execute_ps(
         r'$v = Get-ChildItem -Path C:\hgdev\src\dist -Filter "%s" '
         '| Sort-Object LastWriteTime -Descending '
         '| Select-Object -First 1\n'
         '$v.name' % pattern
     )
     return res[0]
 
 
 def copy_latest_dist(winrm_client, pattern, dest_path):
     """Copy latest file matching pattern in dist/ directory.
 
     Given a WinRM client and a file pattern, find the latest file on the remote
     matching that pattern and copy it to the ``dest_path`` directory on the
     local machine.
     """
     latest = find_latest_dist(winrm_client, pattern)
     source = r'C:\hgdev\src\dist\%s' % latest
     dest = dest_path / latest
     print('copying %s to %s' % (source, dest))
     winrm_client.fetch(source, str(dest))
 
 
 def build_inno_installer(
     winrm_client, arch: str, dest_path: pathlib.Path, version=None
 ):
     """Build the Inno Setup installer on a remote machine.
 
     Using a WinRM client, remote commands are executed to build
     a Mercurial Inno Setup installer.
     """
     print('building Inno Setup installer for %s' % arch)
 
     extra_args = []
     if version:
         extra_args.extend(['--version', version])
 
     ps = get_vc_prefix(arch) + BUILD_INNO.format(
         arch=arch, extra_args=' '.join(extra_args)
     )
     run_powershell(winrm_client, ps)
     copy_latest_dist(winrm_client, '*.exe', dest_path)
 
 
 def build_wheel(
     winrm_client, python_version: str, arch: str, dest_path: pathlib.Path
 ):
     """Build Python wheels on a remote machine.
 
     Using a WinRM client, remote commands are executed to build a Python wheel
     for Mercurial.
     """
     print('Building Windows wheel for Python %s %s' % (python_version, arch))
 
     ps = BUILD_WHEEL.format(
         python_version=python_version.replace(".", ""), arch=arch
     )
 
     # Python 2.7 requires an activated environment.
     if python_version == "2.7":
         ps = get_vc_prefix(arch) + ps
 
     run_powershell(winrm_client, ps)
     copy_latest_dist(winrm_client, '*.whl', dest_path)
 
 
 def build_wix_installer(
     winrm_client, arch: str, dest_path: pathlib.Path, version=None
 ):
     """Build the WiX installer on a remote machine.
 
     Using a WinRM client, remote commands are executed to build a WiX installer.
     """
     print('Building WiX installer for %s' % arch)
     extra_args = []
     if version:
         extra_args.extend(['--version', version])
 
     ps = get_vc_prefix(arch) + BUILD_WIX.format(
         arch=arch, extra_args=' '.join(extra_args)
     )
     run_powershell(winrm_client, ps)
     copy_latest_dist(winrm_client, '*.msi', dest_path)
 
 
 def run_tests(winrm_client, python_version, arch, test_flags=''):
     """Run tests on a remote Windows machine.
 
     ``python_version`` is a ``X.Y`` string like ``2.7`` or ``3.7``.
     ``arch`` is ``x86`` or ``x64``.
     ``test_flags`` is a str representing extra arguments to pass to
     ``run-tests.py``.
     """
     if not re.match(r'\d\.\d', python_version):
         raise ValueError(
             r'python_version must be \d.\d; got %s' % python_version
         )
 
     if arch not in ('x86', 'x64'):
         raise ValueError('arch must be x86 or x64; got %s' % arch)
 
     python_path = 'python%s-%s' % (python_version.replace('.', ''), arch)
 
     ps = RUN_TESTS.format(python_path=python_path, test_flags=test_flags or '',)
 
     run_powershell(winrm_client, ps)
 
 
 def resolve_wheel_artifacts(dist_path: pathlib.Path, version: str):
     return (
         dist_path / WHEEL_FILENAME_PYTHON27_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON27_X64.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON37_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON37_X64.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON38_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON38_X64.format(version=version),
     )
 
 
 def resolve_all_artifacts(dist_path: pathlib.Path, version: str):
     return (
         dist_path / WHEEL_FILENAME_PYTHON27_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON27_X64.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON37_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON37_X64.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON38_X86.format(version=version),
         dist_path / WHEEL_FILENAME_PYTHON38_X64.format(version=version),
         dist_path / X86_EXE_FILENAME.format(version=version),
         dist_path / X64_EXE_FILENAME.format(version=version),
         dist_path / X86_MSI_FILENAME.format(version=version),
         dist_path / X64_MSI_FILENAME.format(version=version),
     )
 
 
 def generate_latest_dat(version: str):
     x86_exe_filename = X86_EXE_FILENAME.format(version=version)
     x64_exe_filename = X64_EXE_FILENAME.format(version=version)
     x86_msi_filename = X86_MSI_FILENAME.format(version=version)
     x64_msi_filename = X64_MSI_FILENAME.format(version=version)
 
     entries = (
         (
             '10',
             version,
             X86_USER_AGENT_PATTERN,
             '%s/%s' % (MERCURIAL_SCM_BASE_URL, x86_exe_filename),
             X86_EXE_DESCRIPTION.format(version=version),
         ),
         (
             '10',
             version,
             X64_USER_AGENT_PATTERN,
             '%s/%s' % (MERCURIAL_SCM_BASE_URL, x64_exe_filename),
             X64_EXE_DESCRIPTION.format(version=version),
         ),
         (
             '10',
             version,
             X86_USER_AGENT_PATTERN,
             '%s/%s' % (MERCURIAL_SCM_BASE_URL, x86_msi_filename),
             X86_MSI_DESCRIPTION.format(version=version),
         ),
         (
             '10',
             version,
             X64_USER_AGENT_PATTERN,
             '%s/%s' % (MERCURIAL_SCM_BASE_URL, x64_msi_filename),
             X64_MSI_DESCRIPTION.format(version=version),
         ),
     )
 
     lines = ['\t'.join(e) for e in entries]
 
     return '\n'.join(lines) + '\n'
 
 
 def publish_artifacts_pypi(dist_path: pathlib.Path, version: str):
     """Publish Windows release artifacts to PyPI."""
 
     wheel_paths = resolve_wheel_artifacts(dist_path, version)
 
     for p in wheel_paths:
         if not p.exists():
             raise Exception('%s not found' % p)
 
     print('uploading wheels to PyPI (you may be prompted for credentials)')
     pypi_upload(wheel_paths)
 
 
 def publish_artifacts_mercurial_scm_org(
     dist_path: pathlib.Path, version: str, ssh_username=None
 ):
     """Publish Windows release artifacts to mercurial-scm.org."""
     all_paths = resolve_all_artifacts(dist_path, version)
 
     for p in all_paths:
         if not p.exists():
             raise Exception('%s not found' % p)
 
     client = paramiko.SSHClient()
     client.load_system_host_keys()
     # We assume the system SSH configuration knows how to connect.
     print('connecting to mercurial-scm.org via ssh...')
     try:
         client.connect('mercurial-scm.org', username=ssh_username)
     except paramiko.AuthenticationException:
         print('error authenticating; is an SSH key available in an SSH agent?')
         raise
 
     print('SSH connection established')
 
     print('opening SFTP client...')
     sftp = client.open_sftp()
     print('SFTP client obtained')
 
     for p in all_paths:
         dest_path = '/var/www/release/windows/%s' % p.name
         print('uploading %s to %s' % (p, dest_path))
 
         with p.open('rb') as fh:
             data = fh.read()
 
         with sftp.open(dest_path, 'wb') as fh:
             fh.write(data)
             fh.chmod(0o0664)
 
     latest_dat_path = '/var/www/release/windows/latest.dat'
 
     now = datetime.datetime.utcnow()
     backup_path = dist_path / (
         'latest-windows-%s.dat' % now.strftime('%Y%m%dT%H%M%S')
     )
     print('backing up %s to %s' % (latest_dat_path, backup_path))
 
     with sftp.open(latest_dat_path, 'rb') as fh:
         latest_dat_old = fh.read()
 
     with backup_path.open('wb') as fh:
         fh.write(latest_dat_old)
 
     print('writing %s with content:' % latest_dat_path)
     latest_dat_content = generate_latest_dat(version)
     print(latest_dat_content)
 
     with sftp.open(latest_dat_path, 'wb') as fh:
         fh.write(latest_dat_content.encode('ascii'))
 
 
 def publish_artifacts(
     dist_path: pathlib.Path,
     version: str,
     pypi=True,
     mercurial_scm_org=True,
     ssh_username=None,
 ):
     """Publish Windows release artifacts.
 
     Files are found in `dist_path`. We will look for files with version string
     `version`.
 
     `pypi` controls whether we upload to PyPI.
     `mercurial_scm_org` controls whether we upload to mercurial-scm.org.
     """
     if pypi:
         publish_artifacts_pypi(dist_path, version)
 
     if mercurial_scm_org:
         publish_artifacts_mercurial_scm_org(
             dist_path, version, ssh_username=ssh_username
         )

contrib/packaging/hgpackaging/inno.py

@@ -1,227 +1,232 b''
 # inno.py - Inno Setup functionality.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import shutil
 import subprocess
 
 import jinja2
 
 from .py2exe import (
     build_py2exe,
     stage_install,
 )
 from .pyoxidizer import run_pyoxidizer
 from .util import (
     find_legacy_vc_runtime_files,
     normalize_windows_version,
     process_install_rules,
     read_version_py,
 )
 
 EXTRA_PACKAGES = {
     'dulwich',
     'keyring',
     'pygments',
     'win32ctypes',
 }
 
 EXTRA_INSTALL_RULES = [
     ('contrib/win32/mercurial.ini', 'defaultrc/mercurial.rc'),
 ]
 
 PACKAGE_FILES_METADATA = {
     'ReadMe.html': 'Flags: isreadme',
 }
 
 
 def build_with_py2exe(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     python_exe: pathlib.Path,
     iscc_exe: pathlib.Path,
     version=None,
 ):
     """Build the Inno installer using py2exe.
 
     Build files will be placed in ``build_dir``.
 
     py2exe's setup.py doesn't use setuptools. It doesn't have modern logic
     for finding the Python 2.7 toolchain. So, we require the environment
     to already be configured with an active toolchain.
     """
     if not iscc_exe.exists():
         raise Exception('%s does not exist' % iscc_exe)
 
     vc_x64 = r'\x64' in os.environ.get('LIB', '')
     arch = 'x64' if vc_x64 else 'x86'
     inno_build_dir = build_dir / ('inno-py2exe-%s' % arch)
     staging_dir = inno_build_dir / 'stage'
 
     requirements_txt = (
         source_dir / 'contrib' / 'packaging' / 'requirements_win32.txt'
     )
 
     inno_build_dir.mkdir(parents=True, exist_ok=True)
 
     build_py2exe(
         source_dir,
         build_dir,
         python_exe,
         'inno',
         requirements_txt,
         extra_packages=EXTRA_PACKAGES,
     )
 
     # Purge the staging directory for every build so packaging is
     # pristine.
     if staging_dir.exists():
         print('purging %s' % staging_dir)
         shutil.rmtree(staging_dir)
 
     # Now assemble all the packaged files into the staging directory.
     stage_install(source_dir, staging_dir)
 
     # We also install some extra files.
     process_install_rules(EXTRA_INSTALL_RULES, source_dir, staging_dir)
 
     # hg.exe depends on VC9 runtime DLLs. Copy those into place.
     for f in find_legacy_vc_runtime_files(vc_x64):
         if f.name.endswith('.manifest'):
             basename = 'Microsoft.VC90.CRT.manifest'
         else:
             basename = f.name
 
         dest_path = staging_dir / basename
 
         print('copying %s to %s' % (f, dest_path))
         shutil.copyfile(f, dest_path)
 
     build_installer(
         source_dir,
         inno_build_dir,
         staging_dir,
         iscc_exe,
         version,
         arch="x64" if vc_x64 else None,
+        suffix="-python2",
     )
 
 
 def build_with_pyoxidizer(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     target_triple: str,
     iscc_exe: pathlib.Path,
     version=None,
 ):
     """Build the Inno installer using PyOxidizer."""
     if not iscc_exe.exists():
         raise Exception("%s does not exist" % iscc_exe)
 
     inno_build_dir = build_dir / ("inno-pyoxidizer-%s" % target_triple)
     staging_dir = inno_build_dir / "stage"
 
     inno_build_dir.mkdir(parents=True, exist_ok=True)
     run_pyoxidizer(source_dir, inno_build_dir, staging_dir, target_triple)
 
     process_install_rules(EXTRA_INSTALL_RULES, source_dir, staging_dir)
 
     build_installer(
         source_dir,
         inno_build_dir,
         staging_dir,
         iscc_exe,
         version,
         arch="x64" if "x86_64" in target_triple else None,
     )
 
 
 def build_installer(
     source_dir: pathlib.Path,
     inno_build_dir: pathlib.Path,
     staging_dir: pathlib.Path,
     iscc_exe: pathlib.Path,
     version,
     arch=None,
+    suffix="",
 ):
     """Build an Inno installer from staged Mercurial files.
 
     This function is agnostic about how to build Mercurial. It just
     cares that Mercurial files are in ``staging_dir``.
     """
     inno_source_dir = source_dir / "contrib" / "packaging" / "inno"
 
     # The final package layout is simply a mirror of the staging directory.
     package_files = []
     for root, dirs, files in os.walk(staging_dir):
         dirs.sort()
 
         root = pathlib.Path(root)
 
         for f in sorted(files):
             full = root / f
             rel = full.relative_to(staging_dir)
             if str(rel.parent) == '.':
                 dest_dir = '{app}'
             else:
                 dest_dir = '{app}\\%s' % rel.parent
 
             package_files.append(
                 {
                     'source': rel,
                     'dest_dir': dest_dir,
                     'metadata': PACKAGE_FILES_METADATA.get(str(rel), None),
                 }
             )
 
     print('creating installer')
 
     # Install Inno files by rendering a template.
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(str(inno_source_dir)),
         # Need to change these to prevent conflict with Inno Setup.
         comment_start_string='{##',
         comment_end_string='##}',
     )
 
     try:
         template = jinja_env.get_template('mercurial.iss')
     except jinja2.TemplateSyntaxError as e:
         raise Exception(
             'template syntax error at %s:%d: %s'
             % (e.name, e.lineno, e.message,)
         )
 
     content = template.render(package_files=package_files)
 
     with (inno_build_dir / 'mercurial.iss').open('w', encoding='utf-8') as fh:
         fh.write(content)
 
     # Copy additional files used by Inno.
     for p in ('mercurial.ico', 'postinstall.txt'):
         shutil.copyfile(
             source_dir / 'contrib' / 'win32' / p, inno_build_dir / p
         )
 
     args = [str(iscc_exe)]
 
     if arch:
         args.append('/dARCH=%s' % arch)
+        args.append('/dSUFFIX=-%s%s' % (arch, suffix))
+    else:
+        args.append('/dSUFFIX=-x86%s' % suffix)
 
     if not version:
         version = read_version_py(source_dir)
 
     args.append('/dVERSION=%s' % version)
     args.append('/dQUAD_VERSION=%s' % normalize_windows_version(version))
 
     args.append('/Odist')
     args.append(str(inno_build_dir / 'mercurial.iss'))
 
     subprocess.run(args, cwd=str(source_dir), check=True)

contrib/packaging/hgpackaging/wix.py

@@ -1,531 +1,535 b''
 # wix.py - WiX installer functionality
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import collections
 import os
 import pathlib
 import re
 import shutil
 import subprocess
 import typing
 import uuid
 import xml.dom.minidom
 
 from .downloads import download_entry
 from .py2exe import (
     build_py2exe,
     stage_install,
 )
 from .pyoxidizer import run_pyoxidizer
 from .util import (
     extract_zip_to_directory,
     normalize_windows_version,
     process_install_rules,
     sign_with_signtool,
 )
 
 
 EXTRA_PACKAGES = {
     'dulwich',
     'distutils',
     'keyring',
     'pygments',
     'win32ctypes',
 }
 
 
 EXTRA_INSTALL_RULES = [
     ('contrib/packaging/wix/COPYING.rtf', 'COPYING.rtf'),
     ('contrib/win32/mercurial.ini', 'defaultrc/mercurial.rc'),
 ]
 
 STAGING_REMOVE_FILES = [
     # We use the RTF variant.
     'copying.txt',
 ]
 
 SHORTCUTS = {
     # hg.1.html'
     'hg.file.5d3e441c_28d9_5542_afd0_cdd4234f12d5': {
         'Name': 'Mercurial Command Reference',
     },
     # hgignore.5.html
     'hg.file.5757d8e0_f207_5e10_a2ec_3ba0a062f431': {
         'Name': 'Mercurial Ignore Files',
     },
     # hgrc.5.html
     'hg.file.92e605fd_1d1a_5dc6_9fc0_5d2998eb8f5e': {
         'Name': 'Mercurial Configuration Files',
     },
 }
 
 
 def find_version(source_dir: pathlib.Path):
     version_py = source_dir / 'mercurial' / '__version__.py'
 
     with version_py.open('r', encoding='utf-8') as fh:
         source = fh.read().strip()
 
     m = re.search('version = b"(.*)"', source)
     return m.group(1)
 
 
 def ensure_vc90_merge_modules(build_dir):
     x86 = (
         download_entry(
             'vc9-crt-x86-msm',
             build_dir,
             local_name='microsoft.vcxx.crt.x86_msm.msm',
         )[0],
         download_entry(
             'vc9-crt-x86-msm-policy',
             build_dir,
             local_name='policy.x.xx.microsoft.vcxx.crt.x86_msm.msm',
         )[0],
     )
 
     x64 = (
         download_entry(
             'vc9-crt-x64-msm',
             build_dir,
             local_name='microsoft.vcxx.crt.x64_msm.msm',
         )[0],
         download_entry(
             'vc9-crt-x64-msm-policy',
             build_dir,
             local_name='policy.x.xx.microsoft.vcxx.crt.x64_msm.msm',
         )[0],
     )
     return {
         'x86': x86,
         'x64': x64,
     }
 
 
 def run_candle(wix, cwd, wxs, source_dir, defines=None):
     args = [
         str(wix / 'candle.exe'),
         '-nologo',
         str(wxs),
         '-dSourceDir=%s' % source_dir,
     ]
 
     if defines:
         args.extend('-d%s=%s' % define for define in sorted(defines.items()))
 
     subprocess.run(args, cwd=str(cwd), check=True)
 
 
 def make_files_xml(staging_dir: pathlib.Path, is_x64) -> str:
     """Create XML string listing every file to be installed."""
 
     # We derive GUIDs from a deterministic file path identifier.
     # We shoehorn the name into something that looks like a URL because
     # the UUID namespaces are supposed to work that way (even though
     # the input data probably is never validated).
 
     doc = xml.dom.minidom.parseString(
         '<?xml version="1.0" encoding="utf-8"?>'
         '<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">'
         '</Wix>'
     )
 
     # Assemble the install layout by directory. This makes it easier to
     # emit XML, since each directory has separate entities.
     manifest = collections.defaultdict(dict)
 
     for root, dirs, files in os.walk(staging_dir):
         dirs.sort()
 
         root = pathlib.Path(root)
         rel_dir = root.relative_to(staging_dir)
 
         for i in range(len(rel_dir.parts)):
             parent = '/'.join(rel_dir.parts[0 : i + 1])
             manifest.setdefault(parent, {})
 
         for f in sorted(files):
             full = root / f
             manifest[str(rel_dir).replace('\\', '/')][full.name] = full
 
     component_groups = collections.defaultdict(list)
 
     # Now emit a <Fragment> for each directory.
     # Each directory is composed of a <DirectoryRef> pointing to its parent
     # and defines child <Directory>'s and a <Component> with all the files.
     for dir_name, entries in sorted(manifest.items()):
         # The directory id is derived from the path. But the root directory
         # is special.
         if dir_name == '.':
             parent_directory_id = 'INSTALLDIR'
         else:
             parent_directory_id = 'hg.dir.%s' % dir_name.replace('/', '.')
 
         fragment = doc.createElement('Fragment')
         directory_ref = doc.createElement('DirectoryRef')
         directory_ref.setAttribute('Id', parent_directory_id)
 
         # Add <Directory> entries for immediate children directories.
         for possible_child in sorted(manifest.keys()):
             if (
                 dir_name == '.'
                 and '/' not in possible_child
                 and possible_child != '.'
             ):
                 child_directory_id = 'hg.dir.%s' % possible_child
                 name = possible_child
             else:
                 if not possible_child.startswith('%s/' % dir_name):
                     continue
                 name = possible_child[len(dir_name) + 1 :]
                 if '/' in name:
                     continue
 
                 child_directory_id = 'hg.dir.%s' % possible_child.replace(
                     '/', '.'
                 )
 
             directory = doc.createElement('Directory')
             directory.setAttribute('Id', child_directory_id)
             directory.setAttribute('Name', name)
             directory_ref.appendChild(directory)
 
         # Add <Component>s for files in this directory.
         for rel, source_path in sorted(entries.items()):
             if dir_name == '.':
                 full_rel = rel
             else:
                 full_rel = '%s/%s' % (dir_name, rel)
 
             component_unique_id = (
                 'https://www.mercurial-scm.org/wix-installer/0/component/%s'
                 % full_rel
             )
             component_guid = uuid.uuid5(uuid.NAMESPACE_URL, component_unique_id)
             component_id = 'hg.component.%s' % str(component_guid).replace(
                 '-', '_'
             )
 
             component = doc.createElement('Component')
 
             component.setAttribute('Id', component_id)
             component.setAttribute('Guid', str(component_guid).upper())
             component.setAttribute('Win64', 'yes' if is_x64 else 'no')
 
             # Assign this component to a top-level group.
             if dir_name == '.':
                 component_groups['ROOT'].append(component_id)
             elif '/' in dir_name:
                 component_groups[dir_name[0 : dir_name.index('/')]].append(
                     component_id
                 )
             else:
                 component_groups[dir_name].append(component_id)
 
             unique_id = (
                 'https://www.mercurial-scm.org/wix-installer/0/%s' % full_rel
             )
             file_guid = uuid.uuid5(uuid.NAMESPACE_URL, unique_id)
 
             # IDs have length limits. So use GUID to derive them.
             file_guid_normalized = str(file_guid).replace('-', '_')
             file_id = 'hg.file.%s' % file_guid_normalized
 
             file_element = doc.createElement('File')
             file_element.setAttribute('Id', file_id)
             file_element.setAttribute('Source', str(source_path))
             file_element.setAttribute('KeyPath', 'yes')
             file_element.setAttribute('ReadOnly', 'yes')
 
             component.appendChild(file_element)
             directory_ref.appendChild(component)
 
         fragment.appendChild(directory_ref)
         doc.documentElement.appendChild(fragment)
 
     for group, component_ids in sorted(component_groups.items()):
         fragment = doc.createElement('Fragment')
         component_group = doc.createElement('ComponentGroup')
         component_group.setAttribute('Id', 'hg.group.%s' % group)
 
         for component_id in component_ids:
             component_ref = doc.createElement('ComponentRef')
             component_ref.setAttribute('Id', component_id)
             component_group.appendChild(component_ref)
 
         fragment.appendChild(component_group)
         doc.documentElement.appendChild(fragment)
 
     # Add <Shortcut> to files that have it defined.
     for file_id, metadata in sorted(SHORTCUTS.items()):
         els = doc.getElementsByTagName('File')
         els = [el for el in els if el.getAttribute('Id') == file_id]
 
         if not els:
             raise Exception('could not find File[Id=%s]' % file_id)
 
         for el in els:
             shortcut = doc.createElement('Shortcut')
             shortcut.setAttribute('Id', 'hg.shortcut.%s' % file_id)
             shortcut.setAttribute('Directory', 'ProgramMenuDir')
             shortcut.setAttribute('Icon', 'hgIcon.ico')
             shortcut.setAttribute('IconIndex', '0')
             shortcut.setAttribute('Advertise', 'yes')
             for k, v in sorted(metadata.items()):
                 shortcut.setAttribute(k, v)
 
             el.appendChild(shortcut)
 
     return doc.toprettyxml()
 
 
 def build_installer_py2exe(
     source_dir: pathlib.Path,
     python_exe: pathlib.Path,
     msi_name='mercurial',
     version=None,
     extra_packages_script=None,
     extra_wxs: typing.Optional[typing.Dict[str, str]] = None,
     extra_features: typing.Optional[typing.List[str]] = None,
     signing_info: typing.Optional[typing.Dict[str, str]] = None,
 ):
     """Build a WiX MSI installer using py2exe.
 
     ``source_dir`` is the path to the Mercurial source tree to use.
     ``arch`` is the target architecture. either ``x86`` or ``x64``.
     ``python_exe`` is the path to the Python executable to use/bundle.
     ``version`` is the Mercurial version string. If not defined,
     ``mercurial/__version__.py`` will be consulted.
     ``extra_packages_script`` is a command to be run to inject extra packages
     into the py2exe binary. It should stage packages into the virtualenv and
     print a null byte followed by a newline-separated list of packages that
     should be included in the exe.
     ``extra_wxs`` is a dict of {wxs_name: working_dir_for_wxs_build}.
     ``extra_features`` is a list of additional named Features to include in
     the build. These must match Feature names in one of the wxs scripts.
     """
     arch = 'x64' if r'\x64' in os.environ.get('LIB', '') else 'x86'
 
     hg_build_dir = source_dir / 'build'
 
     requirements_txt = (
         source_dir / 'contrib' / 'packaging' / 'requirements_win32.txt'
     )
 
     build_py2exe(
         source_dir,
         hg_build_dir,
         python_exe,
         'wix',
         requirements_txt,
         extra_packages=EXTRA_PACKAGES,
         extra_packages_script=extra_packages_script,
     )
 
     build_dir = hg_build_dir / ('wix-%s' % arch)
     staging_dir = build_dir / 'stage'
 
     build_dir.mkdir(exist_ok=True)
 
     # Purge the staging directory for every build so packaging is pristine.
     if staging_dir.exists():
         print('purging %s' % staging_dir)
         shutil.rmtree(staging_dir)
 
     stage_install(source_dir, staging_dir, lower_case=True)
 
     # We also install some extra files.
     process_install_rules(EXTRA_INSTALL_RULES, source_dir, staging_dir)
 
     # And remove some files we don't want.
     for f in STAGING_REMOVE_FILES:
         p = staging_dir / f
         if p.exists():
             print('removing %s' % p)
             p.unlink()
 
     return run_wix_packaging(
         source_dir,
         build_dir,
         staging_dir,
         arch,
         version=version,
         python2=True,
         msi_name=msi_name,
+        suffix="-python2",
         extra_wxs=extra_wxs,
         extra_features=extra_features,
         signing_info=signing_info,
     )
 
 
 def build_installer_pyoxidizer(
     source_dir: pathlib.Path,
     target_triple: str,
     msi_name='mercurial',
     version=None,
     extra_wxs: typing.Optional[typing.Dict[str, str]] = None,
     extra_features: typing.Optional[typing.List[str]] = None,
     signing_info: typing.Optional[typing.Dict[str, str]] = None,
 ):
     """Build a WiX MSI installer using PyOxidizer."""
     hg_build_dir = source_dir / "build"
     build_dir = hg_build_dir / ("wix-%s" % target_triple)
     staging_dir = build_dir / "stage"
 
     arch = "x64" if "x86_64" in target_triple else "x86"
 
     build_dir.mkdir(parents=True, exist_ok=True)
     run_pyoxidizer(source_dir, build_dir, staging_dir, target_triple)
 
     # We also install some extra files.
     process_install_rules(EXTRA_INSTALL_RULES, source_dir, staging_dir)
 
     # And remove some files we don't want.
     for f in STAGING_REMOVE_FILES:
         p = staging_dir / f
         if p.exists():
             print('removing %s' % p)
             p.unlink()
 
     return run_wix_packaging(
         source_dir,
         build_dir,
         staging_dir,
         arch,
         version,
         python2=False,
         msi_name=msi_name,
         extra_wxs=extra_wxs,
         extra_features=extra_features,
         signing_info=signing_info,
     )
 
 
 def run_wix_packaging(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     staging_dir: pathlib.Path,
     arch: str,
     version: str,
     python2: bool,
     msi_name: typing.Optional[str] = "mercurial",
+    suffix: str = "",
     extra_wxs: typing.Optional[typing.Dict[str, str]] = None,
     extra_features: typing.Optional[typing.List[str]] = None,
     signing_info: typing.Optional[typing.Dict[str, str]] = None,
 ):
     """Invokes WiX to package up a built Mercurial.
 
     ``signing_info`` is a dict defining properties to facilitate signing the
     installer. Recognized keys include ``name``, ``subject_name``,
     ``cert_path``, ``cert_password``, and ``timestamp_url``. If populated,
     we will sign both the hg.exe and the .msi using the signing credentials
     specified.
     """
 
     orig_version = version or find_version(source_dir)
     version = normalize_windows_version(orig_version)
     print('using version string: %s' % version)
     if version != orig_version:
         print('(normalized from: %s)' % orig_version)
 
     if signing_info:
         sign_with_signtool(
             staging_dir / "hg.exe",
             "%s %s" % (signing_info["name"], version),
             subject_name=signing_info["subject_name"],
             cert_path=signing_info["cert_path"],
             cert_password=signing_info["cert_password"],
             timestamp_url=signing_info["timestamp_url"],
         )
 
     wix_dir = source_dir / 'contrib' / 'packaging' / 'wix'
 
     wix_pkg, wix_entry = download_entry('wix', build_dir)
     wix_path = build_dir / ('wix-%s' % wix_entry['version'])
 
     if not wix_path.exists():
         extract_zip_to_directory(wix_pkg, wix_path)
 
     if python2:
         ensure_vc90_merge_modules(build_dir)
 
     source_build_rel = pathlib.Path(os.path.relpath(source_dir, build_dir))
 
     defines = {'Platform': arch}
 
     # Derive a .wxs file with the staged files.
     manifest_wxs = build_dir / 'stage.wxs'
     with manifest_wxs.open('w', encoding='utf-8') as fh:
         fh.write(make_files_xml(staging_dir, is_x64=arch == 'x64'))
 
     run_candle(wix_path, build_dir, manifest_wxs, staging_dir, defines=defines)
 
     for source, rel_path in sorted((extra_wxs or {}).items()):
         run_candle(wix_path, build_dir, source, rel_path, defines=defines)
 
     source = wix_dir / 'mercurial.wxs'
     defines['Version'] = version
     defines['Comments'] = 'Installs Mercurial version %s' % version
 
     if python2:
         defines["PythonVersion"] = "2"
         defines['VCRedistSrcDir'] = str(build_dir)
     else:
         defines["PythonVersion"] = "3"
 
     if (staging_dir / "lib").exists():
         defines["MercurialHasLib"] = "1"
 
     if extra_features:
         assert all(';' not in f for f in extra_features)
         defines['MercurialExtraFeatures'] = ';'.join(extra_features)
 
     run_candle(wix_path, build_dir, source, source_build_rel, defines=defines)
 
     msi_path = (
-        source_dir / 'dist' / ('%s-%s-%s.msi' % (msi_name, orig_version, arch))
+        source_dir
+        / 'dist'
+        / ('%s-%s-%s%s.msi' % (msi_name, orig_version, arch, suffix))
     )
 
     args = [
         str(wix_path / 'light.exe'),
         '-nologo',
         '-ext',
         'WixUIExtension',
         '-sw1076',
         '-spdb',
         '-o',
         str(msi_path),
     ]
 
     for source, rel_path in sorted((extra_wxs or {}).items()):
         assert source.endswith('.wxs')
         source = os.path.basename(source)
         args.append(str(build_dir / ('%s.wixobj' % source[:-4])))
 
     args.extend(
         [str(build_dir / 'stage.wixobj'), str(build_dir / 'mercurial.wixobj'),]
     )
 
     subprocess.run(args, cwd=str(source_dir), check=True)
 
     print('%s created' % msi_path)
 
     if signing_info:
         sign_with_signtool(
             msi_path,
             "%s %s" % (signing_info["name"], version),
             subject_name=signing_info["subject_name"],
             cert_path=signing_info["cert_path"],
             cert_password=signing_info["cert_password"],
             timestamp_url=signing_info["timestamp_url"],
         )
 
     return {
         'msi_path': msi_path,
     }

contrib/packaging/inno/mercurial.iss

@@ -1,83 +1,82 b''
 ; Script generated by the Inno Setup Script Wizard.
 ; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
 
 #ifndef ARCH
 #define ARCH = "x86"
 #endif
 
 [Setup]
 AppCopyright=Copyright 2005-2020 Matt Mackall and others
 AppName=Mercurial
 AppVersion={#VERSION}
+OutputBaseFilename=Mercurial-{#VERSION}{#SUFFIX}
 #if ARCH == "x64"
 AppVerName=Mercurial {#VERSION} (64-bit)
-OutputBaseFilename=Mercurial-{#VERSION}-x64
 ArchitecturesAllowed=x64
 ArchitecturesInstallIn64BitMode=x64
 #else
 AppVerName=Mercurial {#VERSION}
-OutputBaseFilename=Mercurial-{#VERSION}
 #endif
 InfoAfterFile=../postinstall.txt
 LicenseFile=Copying.txt
 ShowLanguageDialog=yes
 AppPublisher=Matt Mackall and others
 AppPublisherURL=https://mercurial-scm.org/
 AppSupportURL=https://mercurial-scm.org/
 AppUpdatesURL=https://mercurial-scm.org/
 {{ 'AppID={{4B95A5F1-EF59-4B08-BED8-C891C46121B3}' }}
 AppContact=[e-mail]
 DefaultDirName={pf}\Mercurial
 SourceDir=stage
 VersionInfoDescription=Mercurial distributed SCM (version {#VERSION})
 VersionInfoCopyright=Copyright 2005-2020 Matt Mackall and others
 VersionInfoCompany=Matt Mackall and others
 VersionInfoVersion={#QUAD_VERSION}
 InternalCompressLevel=max
 SolidCompression=true
 SetupIconFile=../mercurial.ico
 AllowNoIcons=true
 DefaultGroupName=Mercurial
 PrivilegesRequired=none
 ChangesEnvironment=true
 
 [Files]
 {% for entry in package_files -%}
 Source: {{ entry.source }}; DestDir: {{ entry.dest_dir }}
 {%- if entry.metadata %}; {{ entry.metadata }}{% endif %}
 {% endfor %}
 
 [INI]
 Filename: {app}\Mercurial.url; Section: InternetShortcut; Key: URL; String: https://mercurial-scm.org/
 
 [UninstallDelete]
 Type: files; Name: {app}\Mercurial.url
 Type: filesandordirs; Name: {app}\defaultrc
 
 [Icons]
 Name: {group}\Uninstall Mercurial; Filename: {uninstallexe}
 Name: {group}\Mercurial Command Reference; Filename: {app}\Docs\hg.1.html
 Name: {group}\Mercurial Configuration Files; Filename: {app}\Docs\hgrc.5.html
 Name: {group}\Mercurial Ignore Files; Filename: {app}\Docs\hgignore.5.html
 Name: {group}\Mercurial Web Site; Filename: {app}\Mercurial.url
 
 [Tasks]
 Name: modifypath; Description: Add the installation path to the search path; Flags: unchecked
 
 [Code]
 procedure Touch(fn: String);
 begin
   SaveStringToFile(ExpandConstant(fn), '', False);
 end;
 
 const
     ModPathName = 'modifypath';
     ModPathType = 'user';
 
 function ModPathDir(): TArrayOfString;
 begin
     setArrayLength(Result, 1)
     Result[0] := ExpandConstant('{app}');
 end;
 
 {% include 'modpath.iss' %}