DEVenv/devenver.py
2024-01-10 12:14:15 +11:00

833 lines
38 KiB
Python

#!/usr/bin/env python3
# DEVenver
# ------------------------------------------------------------------------------
# A simple python script to download portable applications and install them by
# unzipping them to a structured directory tree.
import urllib.request
import urllib.parse
import pathlib
import os
import tempfile
import hashlib
import shutil
import subprocess
import pprint
import argparse
import json
import importlib
from string import Template
from enum import Enum
# Internal
# ------------------------------------------------------------------------------
DOWNLOAD_CHUNK_SIZE = 1 * 1024 * 1024 # 1 megabyte
# ------------------------------------------------------------------------------
# These variables are set once they are downloaded dynamically and installed
# from the internal app listing!
zstd_exe = ""
zip7_exe = ""
zip7_bootstrap_exe = ""
# Functions
# ------------------------------------------------------------------------------
def print_header(title):
line = f'> ' + title + ' ';
print(line.ljust(100, '-'))
def lprint(*args, level=0, **kwargs):
print(' ' + (' ' * 2 * level), *args, **kwargs)
def lexit(*args, level=0, **kwargs):
print(' ' + (' ' * 2 * level), *args, **kwargs)
exit()
def verify_file_sha256(file_path, checksum, label):
if os.path.isfile(file_path) == False:
exit(f'Cannot verify SHA256, path is not a file [path={file_path}]')
result = False
try:
file = open(file_path, 'rb')
hasher = hashlib.sha256()
hasher.update(file.read())
derived_checksum = hasher.hexdigest()
result = derived_checksum == checksum
if result:
lprint(f'- {label} SHA256 is good: {checksum}', level=1)
else:
lprint(f'- {label} SHA256 mismatch', level=1)
lprint(f' Expect: {checksum}', level=1)
lprint(f' Actual: {derived_checksum}', level=1)
except PermissionError as exception:
lprint(f"- {label} cannot verify SHA256 due to permission error, skipping", level=1)
result = True
else:
file.close()
return result
def download_file_at_url(url, download_path, download_checksum, label):
# Check if file already downloaded and hashes match
# --------------------------------------------------------------------------
file_already_downloaded = False
if os.path.isfile(download_path):
lprint(f'- Cached archive found: {download_path}', level=1)
file_already_downloaded = verify_file_sha256(download_path, download_checksum, 'Cached archive')
else:
lprint(f'- Download to disk: {download_path}', level=1)
lprint(f' URL: {url}', level=1)
# Download the file from URL
# --------------------------------------------------------------------------
if file_already_downloaded == False:
lprint('Initiating download request ...', level=2)
with urllib.request.urlopen(url) as response:
temp_file = tempfile.mkstemp(text=False)
temp_file_handle = temp_file[0]
temp_file_path = temp_file[1]
temp_file_io = os.fdopen(temp_file_handle, mode='w+b')
download_failed = False
try:
line = ''
total_download_size = int(response.getheader('Content-Length'))
bytes_downloaded = 0
while chunk := response.read(DOWNLOAD_CHUNK_SIZE):
bytes_written = temp_file_io.write(chunk)
bytes_downloaded += bytes_written
percent_downloaded = int(bytes_downloaded / total_download_size * 100)
lprint(' ' * len(line), end='\r', level=2)
line = f'Downloading {percent_downloaded:.2f}% ({bytes_downloaded}/{total_download_size})'
lprint(line, end='\r', level=2)
except Exception as exception:
download_failed = True
lprint(f'Download {label} from {url} failed, {exception}', level=2)
finally:
temp_file_io.close()
print()
if download_failed == True:
os.remove(temp_file_path)
exit()
# If file already exists then we have a hash mismatch, delete it
# then rename the new item ontop of it
if os.path.isfile(download_path):
os.unlink(download_path)
shutil.move(temp_file_path, download_path)
if file_already_downloaded == False:
if verify_file_sha256(download_path, download_checksum, 'Downloaded archive') == False:
exit()
class UnzipMethod(Enum):
SHUTILS = 0
ZIP7_BOOTSTRAP = 1
DEFAULT = 2
ZIP7 = 3
NO_UNZIP = 4
def get_exe_install_dir(install_dir, label, version_label):
result = pathlib.Path(install_dir, label.replace(' ', '_'), version_label)
return result
def get_exe_install_path(install_dir, label, version_label, exe_rel_path):
install_dir = get_exe_install_dir(install_dir, label, version_label)
result = pathlib.Path(install_dir, exe_rel_path)
return result
def get_exe_symlink_dir(install_dir):
result = pathlib.Path(install_dir, "Symlinks")
return result
def download_and_install_archive(download_url,
download_checksum,
exe_list,
version_label,
label,
unzip_method,
download_dir,
install_dir,
is_windows):
exe_install_dir = get_exe_install_dir(install_dir=install_dir,
label=label,
version_label=version_label)
# Evaluate if we have already installed the requested archive
# --------------------------------------------------------------------------
exes_are_not_a_file = []
exes_missing = []
exes_present = []
for exe_dict in exe_list:
exe_path = get_exe_install_path(install_dir=install_dir,
label=label,
version_label=version_label,
exe_rel_path=exe_dict['path'])
if os.path.exists(exe_path) == True:
if os.path.isfile(exe_path) == True:
exes_present.append(exe_dict)
else:
exes_are_not_a_file.append(exe_dict)
else:
exes_missing.append(exe_dict)
# Executables not install yet, verify, download and install if possible
# --------------------------------------------------------------------------
if len(exes_present) != len(exe_list):
# Check if any of the manifest files are not files
# ----------------------------------------------------------------------
if len(exes_are_not_a_file) > 0: # Some item exists at the path but they are not files
lprint(f'- {label} is installed but some of the expected executables are not a file!', level=1)
for exe_dict in exes_are_not_a_file:
lprint(f' {exe_dict["path"]}', level=1)
lprint(f' Installation cannot proceed as unpacking would overwrite these paths', level=1)
exit()
# Check if any files are missing
# ----------------------------------------------------------------------
# Some executables are missing, some are available, installation will
# trample over existing files, its not safe to unzip the archive as we may
# overwrite config files or some other files that have been modified by the
# program.
#
# Note that all files missing means we can assume that we haven't installed
# yet ..
if len(exes_missing) > 0 and len(exes_missing) != len(exe_list):
lprint(f'- {label} is installed but some of the expected executables are missing from the installation!', level=1)
for exe_dict in exes_are_not_a_file:
lprint(f' {exe_dict["path"]}', level=1)
exit()
assert(len(exes_missing) == len(exe_list))
assert(len(exes_present) == 0)
# Not installed yet, download and install
# ----------------------------------------------------------------------
# Determine the file name we are downloading from the URL
download_url_parts = urllib.parse.urlparse(download_url)
download_name = pathlib.Path(urllib.parse.unquote(download_url_parts.path))
# The path to move the temp file to after successful download, e.g.
# download_dir = C:/Dev/Downloads/Wezterm-windows-{version}.zip
# download_name = Wezterm-windows-{version}.zip
download_path = pathlib.Path(download_dir, download_name.name)
# Download the archive at the URL
download_file_at_url(download_url, download_path, download_checksum, label)
# Install the archive by unpacking it
# ----------------------------------------------------------------------
archive_path = download_path
os.makedirs(exe_install_dir, exist_ok=True)
if unzip_method == UnzipMethod.DEFAULT:
if archive_path.suffix == '.exe' or archive_path.suffix.lower() == '.appimage' or len(archive_path.suffix) == 0:
unzip_method = UnzipMethod.NO_UNZIP
if unzip_method == UnzipMethod.NO_UNZIP:
shutil.copy(archive_path, exe_install_dir)
elif unzip_method == UnzipMethod.SHUTILS:
lprint(f'- SHUtils unzip install {label} to: {exe_install_dir}', level=1)
shutil.unpack_archive(download_path, exe_install_dir)
elif unzip_method == UnzipMethod.ZIP7_BOOTSTRAP:
command = [str(zip7_bootstrap_exe), "x", "-bd", str(download_path), f"-o{exe_install_dir}"]
lprint(f'- 7z (bootstrap) unzip {label} to: {exe_install_dir}', level=1)
lprint(f' Command: {command}', level=1)
subprocess.run(command)
else: # Default or 7ZIP
intermediate_zip_file_extracted = False
# We could have a "app.zst" situation or an "app.tar.zst" situation
#
# "app.zst" only needs 1 extraction from the zstd tool
# "app.tar.zst" needs 1 zstd extract and then 1 7zip extract
#
# When we have "app.tar.zst" we extract to the install folder, e.g.
#
# "app/1.0/app.tar"
#
# We call this an intermediate zip file, we will extract that file
# with 7zip. After we're done, we will delete that _intermediate_
# file to cleanup our install directory.
unzip_command = [str(zip7_exe), "x", "-aoa", "-spe", "-bso0", str(archive_path), f"-o{exe_install_dir}"]
linux_used_tar = False
if archive_path.suffix == '.zst' or archive_path.suffix == '.xz' or archive_path.suffix == '.gz' or archive_path.suffix == '.bz2':
archive_without_suffix = pathlib.Path(str(archive_path)[:-len(archive_path.suffix)]).name
next_archive_path = pathlib.Path(exe_install_dir, archive_without_suffix)
if os.path.exists(next_archive_path) == False:
command = ""
if archive_path.suffix == '.zst':
command = [str(zstd_exe), "--output-dir-flat", str(exe_install_dir), "-d", str(archive_path)]
lprint(f'- zstd unzip {label} to: {exe_install_dir}', level=1)
else:
if not is_windows:
linux_used_tar = True
unzip_command = ["tar", "xf", str(archive_path), "--directory", str(exe_install_dir)]
command = unzip_command
for item in command:
item = item.replace('\\', '/')
lprint(f'- Unzip nested install {label} to: {exe_install_dir}', level=1)
lprint(f' Command: {command}', level=1)
subprocess.run(args=command)
# Remove the extension from the file, we just extracted it
archive_path = next_archive_path
# If there's still a suffix after we removed the ".zst" we got
# an additional archive to unzip, e.g. "app.tar" remaining.
if not linux_used_tar:
intermediate_zip_file_extracted = len(archive_path.suffix) > 0
# \note On Linux using tar xf will unpack the archive entirely, e.g.
# unpack tar.gz both in one shot. So we do not need a further
# extract step.
if not linux_used_tar and len(archive_path.suffix) > 0:
unzip_command = [str(zip7_exe), "x", "-aoa", "-spe", "-bso0", str(archive_path), f"-o{exe_install_dir}"]
command = unzip_command
for item in command:
item = item.replace('\\', '/')
lprint(f'- Unzip install {label} to: {exe_install_dir}', level=1)
lprint(f' Command: {command}', level=1)
subprocess.run(command)
if intermediate_zip_file_extracted:
lprint(f'- Detected intermediate zip file in install root, removing: {archive_path}', level=1)
os.remove(archive_path)
# Remove duplicate root folder if detected
# ----------------------------------------------------------------------
# If after unpacking, there's only 1 directory in the install direction, we
# assume that the zip contains a root folder. We will automatically merge
# the root folder to the parent.
has_files_in_install_dir = False
dir_count = 0
dupe_root_folder_name = ''
with os.scandir(exe_install_dir) as scan_handle:
for it in list(scan_handle):
if it.is_file():
has_files_in_install_dir = True
break
elif it.is_dir():
dupe_root_folder_name = it.name
dir_count += 1
if dir_count > 1:
break
if dir_count == 1 and not has_files_in_install_dir:
# There is only one folder after we unzipped, what happened here is
# that the archive we unzipped had its contents within a root
# folder. We will pull those files out because we already unzipped
# into an isolated location for the application, e.g.
#
# Our install location C:/Dev/Install/7zip/920
# After unzip C:/Dev/Install/7zip/920/7zip-920-x64
#
# We have an duplicate '7zip-920-x64' directory in our
# installation. Move all the files in the duplicate directory up to
# our '920' folder then remove the duplicate folder.
dupe_root_folder_path = pathlib.Path(exe_install_dir, dupe_root_folder_name)
lprint(f'- Detected duplicate root folder after unzip: {dupe_root_folder_path}', level=1)
lprint(f' Merging duplicate root folder to parent: {exe_install_dir}', level=1)
for file_name in os.listdir(dupe_root_folder_path):
src = pathlib.Path(dupe_root_folder_path, file_name)
dest = pathlib.Path(exe_install_dir, file_name)
shutil.move(src, dest)
os.rmdir(dupe_root_folder_path)
# Verify the installation by checking the SHA256 of the executables
# --------------------------------------------------------------------------
exes_with_bad_hashes = []
for exe_dict in exe_list:
exe_rel_path = exe_dict['path']
exe_path = get_exe_install_path(install_dir=install_dir,
label=label,
version_label=version_label,
exe_rel_path=exe_rel_path)
if os.path.isfile(exe_path) == False:
lexit(f'- Installed {label} but could not find expected file for validating install: {exe_path}', level=1)
if verify_file_sha256(file_path=exe_path, checksum=exe_dict['checksum'], label=exe_rel_path) == False:
exes_with_bad_hashes.append(exe_dict)
if len(exes_with_bad_hashes) > 0:
lprint(f'- {label} is installed but executable SHA256 does not match!', level=1)
lprint(f' See hashes above, executable path(s):', level=1)
for exe_dict in exes_with_bad_hashes:
lprint(f' {exe_dict["path"]}', level=1)
lprint(f' Something has modified the executable, this may be malicious or not!', level=1)
lprint(f' Manually uninstall the existing installation or amend the binary to be', level=1)
lprint(f' able to continue. Exiting.', level=1)
exit()
else:
lprint(f'- {label} installed and valid: {exe_install_dir}', level=1)
# Do the symlinks
# --------------------------------------------------------------------------
symlink_dir = get_exe_symlink_dir(install_dir)
paths_to_add_to_devenv_script = set()
for exe_dict in exe_list:
exe_rel_path = exe_dict['path']
exe_path = get_exe_install_path(install_dir=install_dir,
label=label,
version_label=version_label,
exe_rel_path=exe_rel_path)
# Make them executable
# ----------------------------------------------------------------------
if not is_windows:
subprocess.run(args=["chmod", "+x", exe_path])
# If you install the Linux manifest on Windows then we ensure we
# still call link (e.g. hardlink) because symlinks need special
# Windows 10 permissions to be set...
#
# It's weird that we install Linux manifest on Windows, yes, but
# I use it for testing without having to boot up a whole nother
# OS.
use_hardlink = is_windows or os.name == 'nt'
for symlink_entry in exe_dict["symlink"]:
symlink_dest = symlink_dir / symlink_entry
symlink_src = exe_path
skip_link = False;
if os.path.exists(symlink_dest):
# Windows uses hardlinks because symlinks require you to enable "developer" mode
# Everyone else uses symlinks
if (use_hardlink and not os.path.isfile(symlink_dest)) or (not use_hardlink and not os.path.islink(symlink_dest)):
lprint( "- Cannot create symlink! The destination file to create the symlink at.", level=1)
lprint( " already exists and is *not* a link. We cannot remove this safely as we", level=1)
lprint( " don't know what it is, exiting.", level=1)
lprint(f" Symlink Source: {symlink_src}", level=1)
lexit (f" Symlink Dest: {symlink_dest}", level=1)
if os.path.samefile(symlink_dest, symlink_src):
skip_link = True
else:
os.unlink(symlink_dest)
if not skip_link:
if use_hardlink:
os.link(src=symlink_src, dst=symlink_dest)
else:
os.symlink(src=symlink_src, dst=symlink_dest)
# Collect paths to add to the devenv script
# ----------------------------------------------------------------------
if exe_dict['add_to_devenv_path'] == True:
path = exe_path.parent.relative_to(install_dir)
paths_to_add_to_devenv_script.add(path)
global devenv_script_buffer
for path in paths_to_add_to_devenv_script:
if is_windows:
devenv_script_buffer += f"set PATH=%~dp0{path};%PATH%\n"
else:
devenv_script_buffer += f"PATH=\"$( cd -- $( dirname -- \"${{BASH_SOURCE[0]}}\" ) &> /dev/null && pwd )/{path}\":$PATH\n"
# Search the 2 dictionarries, 'first' and 'second' for the key. A matching key
# in 'first' taking precedence over the 'second' dictionary. If no key is
# found in either dictionaries then this function
# returns an empty string.
class ValidateAppListResult:
def __init__(self):
self.app_count = 0
def validate_app_list(app_list):
result = ValidateAppListResult()
manifest_rule_table = {
'download_checksum': 'manifest must specify the SHA256 checksum for the downloaded file',
'version': 'manifest must specify the app version that is to be installed',
'executables': 'manifest must specify an array of executable(s) for verifying installation',
'download_url': 'manifest must specify the URL to download the app from',
'add_to_devenv_script': 'manifest must specify an array of strings to inject into the portable development environment setup script',
}
executable_rule_table = {
'path': 'executables must specify a path to a file from the installation to verify its checksum',
'symlink': 'executables must specify an array of symlink names that will target the path',
'add_to_devenv_path': 'executables must specify an boolean to indicate if the executable path should be added to the environment path',
'checksum': 'executables must specify a string with the checksum of the executable',
}
for app in app_list:
manifest_list = app['manifests']
result.app_count += len(manifest_list)
# Verify the label
# ----------------------------------------------------------------------
label = app.get('label', '')
if 'label' not in app:
exit('Label missing from application list, app must have a label specified, e.g. { "label": "App Name", "manifests": [] }')
# Verify that the mandatory keys are in the manifest
# ----------------------------------------------------------------------
for manifest in manifest_list:
for key in manifest_rule_table:
value = manifest.get(key, "")
if key.startswith("add_to_devenv"):
if not isinstance(value, list):
exit(f'{label} error: {key} in manifest must be an array to proceed\n{pprint.pformat(app)}')
elif key == "executables":
for executable in value:
for executable_key in executable_rule_table:
executable_value = executable.get(executable_key, "")
if executable_key == "path":
if not isinstance(executable_value, str) or len(executable_value) == 0:
exit(f'{label} error: required key "{executable_key}" is invalid, {executable_rule_table[executable_key]}\n{pprint.pformat(app)}')
elif executable_key == "symlink":
if not isinstance(executable_value, list):
exit(f'{label} error: required key "{executable_key}" is invalid, {executable_rule_table[executable_key]}\n{pprint.pformat(app)}')
elif executable_key == "add_to_devenv_path":
if not isinstance(executable_value, bool):
exit(f'{label} error: required key "{executable_key}" is invalid, {executable_rule_table[executable_key]}\n{pprint.pformat(app)}')
elif executable_key == "checksum":
if not isinstance(executable_value, str):
exit(f'{label} error: required key "{executable_key}" is invalid, {executable_rule_table[executable_key]}\n{pprint.pformat(app)}')
elif len(value) == 0:
exit(f'{label} error: required key "{key}" is missing/empty, {manifest_rule_table[key]}\n{pprint.pformat(app)}')
return result
internal_app_list = []
devenv_script_buffer = ""
def install_app_list(app_list, download_dir, install_dir, is_windows):
title = "Internal Apps" if app_list is internal_app_list else "User Apps"
print_header(title)
result = {}
validate_app_list_result = validate_app_list(app_list)
app_index = 0
global zstd_exe
if not is_windows:
zstd_exe = "/usr/bin/zstd"
for app in app_list:
manifest_list = app['manifests']
for manifest in manifest_list:
app_index += 1
# Extract variables from manifest
# ------------------------------------------------------------------
label = app["label"]
download_checksum = manifest['download_checksum']
version = manifest["version"]
download_url = manifest["download_url"]
exe_list = manifest['executables']
unzip_method = UnzipMethod.DEFAULT
unzip_method_string = manifest.get("unzip_method", "").lower()
if unzip_method_string == 'shutils':
unzip_method = UnzipMethod.SHUTILS
elif unzip_method_string == '7zip bootstrap':
unzip_method = UnzipMethod.ZIP7_BOOTSTRAP
elif unzip_method_string == 'default':
unzip_method = UnzipMethod.DEFAULT
elif unzip_method_string == '7zip':
unzip_method = UnzipMethod.ZIP7
elif unzip_method_string == 'no unzip':
unzip_method = UnzipMethod.NO_UNZIP
# Bootstrapping code, when installing the internal app list, we will
# assign the variables to point to our unarchiving tools.
# ------------------------------------------------------------------
if app_list is internal_app_list:
global zip7_exe
global zip7_bootstrap_exe
exe_path = get_exe_install_path(install_dir, label, version, manifest['executables'][0]['path'])
if label == '7zip':
if is_windows or os.name == 'nt':
if version == '920':
unzip_method = UnzipMethod.SHUTILS
zip7_bootstrap_exe = exe_path
else:
unzip_method = UnzipMethod.ZIP7_BOOTSTRAP
zip7_exe = exe_path
else:
unzip_method = UnzipMethod.SHUTILS
zip7_exe = exe_path
zip7_bootstrap_exe = exe_path
elif label == 'zstd':
zstd_exe = exe_path
# Download and install
# ------------------------------------------------------------------
lprint(f'[{app_index:03}/{validate_app_list_result.app_count:03}] Setup {label} v{version}', level=0)
download_and_install_archive(download_url=download_url,
download_checksum=download_checksum,
exe_list=exe_list,
version_label=version,
label=label,
unzip_method=unzip_method,
download_dir=download_dir,
install_dir=install_dir,
is_windows=is_windows)
# Post-installation
# ------------------------------------------------------------------
# Collate results into results
if label not in result:
result.update({label: []})
for item in exe_list:
app_install_dir = get_exe_install_dir(install_dir, label, version)
app_exe_path = get_exe_install_path(install_dir, label, version, item['path'])
app_exe_dir = pathlib.Path(app_exe_path).parent
# Add executable into the result list
result[label].append({
'version': version,
'install_dir': app_install_dir,
'exe_path': app_exe_path,
})
# Add the snippets verbatim specified in the manifest
global devenv_script_buffer
for line in manifest['add_to_devenv_script']:
devenv_script_buffer += (line + '\n')
if (is_windows or os.name == 'nt') and app_list is internal_app_list:
if len(str(zip7_exe)) == 0 or len(str(zip7_bootstrap_exe)) == 0 or len(str(zstd_exe)) == 0:
exit("Internal app list did not install 7zip bootstrap, 7zip or zstd, we are unable to install archives\n"
f" - zip7_bootstrap_exe: {zip7_bootstrap_exe}\n"
f" - zip7_exe: {zip7_exe}\n"
f" - zstd_exe: {zstd_exe}\n")
return result
script_dir = pathlib.Path(os.path.dirname(os.path.abspath(__file__)))
default_base_dir = script_dir
default_base_downloads_dir = default_base_dir / 'Downloads'
default_base_install_dir = default_base_dir / 'Install'
base_downloads_dir = default_base_downloads_dir
base_install_dir = default_base_install_dir
def run(user_app_list,
devenv_script_name,
is_windows,
download_dir=base_downloads_dir,
install_dir=base_install_dir):
""" Download and install the given user app list at the specified
directories. The apps given must be archives that can be unpacked for
installation (e.g. portable distributions).
Parameters:
user_app_list (list): A list of dictionaries that contain app and
manifest information dictating what is to be installed via this
function.
download_dir (string): The path that intermediate downloaded files will
be kept at.
install_dir (string): The path that installed applications will be
unpacked to
Returns:
result (list): A list of dictionaries containing the install locations
of each app, e.g.
"""
base_downloads_dir = download_dir
base_install_dir = install_dir
# --------------------------------------------------------------------------
# This app list must always be installed, they provide the tools to install all
# other archives. Upon installation, we will collect the installation executable
# path and store them in global variables for the rest of the progam to use to
# unzip the files.
global internal_app_list
internal_app_list = []
internal_app_list.append({
"label": "7zip",
"manifests": [],
})
if is_windows or os.name == "nt":
version = "920"
internal_app_list[-1]["manifests"].append({ # Download the bootstrap 7zip, this can be unzipped using shutils
"download_checksum": "2a3afe19c180f8373fa02ff00254d5394fec0349f5804e0ad2f6067854ff28ac",
"download_url": f"https://www.7-zip.org/a/7za{version}.zip",
"version": version,
"executables": [
{
"path": "7za.exe",
"symlink": [],
"add_to_devenv_path": False,
"checksum": "c136b1467d669a725478a6110ebaaab3cb88a3d389dfa688e06173c066b76fcf"
}
],
"add_to_devenv_script": [],
})
version = "2301"
download_url = ""
download_checksum = ""
checksum = ""
exe_path = ""
if is_windows or os.name == "nt":
download_url = f"https://www.7-zip.org/a/7z{version}-x64.exe"
download_checksum = "26cb6e9f56333682122fafe79dbcdfd51e9f47cc7217dccd29ac6fc33b5598cd"
checksum = "8cebb25e240db3b6986fcaed6bc0b900fa09dad763a56fb71273529266c5c525"
exe_path = "7z.exe"
else:
download_url = f"https://www.7-zip.org/a/7z{version}-linux-x64.tar.xz"
download_checksum = "23babcab045b78016e443f862363e4ab63c77d75bc715c0b3463f6134cbcf318"
checksum = "c7f8769e2bc8df6bcbfba34571ee0340670a52dec824dbac844dd3b5bd1a69e1"
exe_path = "7zz"
internal_app_list[-1]["manifests"].append({ # Download proper 7zip, extract this exe with the bootstrap 7zip
"download_checksum": download_checksum,
"download_url": download_url,
"version": version,
"executables": [
{
"path": exe_path,
"symlink": [],
"add_to_devenv_path": True,
"checksum": checksum,
}
],
"add_to_devenv_script": [],
})
# ------------------------------------------------------------------------------
version = "1.5.2"
download_url = ""
download_checksum = ""
checksum = ""
exe_path = ""
if is_windows or os.name == 'nt':
download_url = f"https://github.com/facebook/zstd/releases/download/v{version}/zstd-v{version}-win64.zip"
download_checksum = "68897cd037ee5e44c6d36b4dbbd04f1cc4202f9037415a3251951b953a257a09"
checksum = "f14e78c0651851a670f508561d2c5d647da0ba08e6b73231f2e7539812bae311"
exe_path = "zstd.exe"
internal_app_list.append({
"label": "zstd",
"manifests": [
{
"download_checksum": download_checksum,
"download_url": download_url,
"version": version,
"executables": [
{
"path": exe_path,
"symlink": [],
"add_to_devenv_path": True,
"checksum": checksum,
},
],
"add_to_devenv_script": [],
},
],
})
# Run
# --------------------------------------------------------------------------
# Create the starting directories and install the internal app list (e.g.
# 7zip) which will be used to unzip-install the rest of the apps in the user
# app list.
#
# To do this without dependencies, we first download an old version of 7zip,
# version 9.20 which is distributed as a .zip file which Python can natively
# unzip.
#
# We then use the old version of 7zip and download a newer version of 7zip
# and extract it using the bootstrap-ed version. As of writing this, 7zip
# does not release a portable distribution of itself yet, instead what we do
# is download the installer and extract it ourselves using the bootstrap
# 7zip.
# Create the paths requested by the user
os.makedirs(download_dir, exist_ok=True)
os.makedirs(install_dir, exist_ok=True)
os.makedirs(pathlib.Path(install_dir, "Symlinks"), exist_ok=True)
for path in [download_dir, install_dir]:
if not os.path.isdir(path):
exit(f'Path "{path}" is not a directory, script can not proceed. Exiting.')
global devenv_script_buffer
if is_windows:
devenv_script_buffer = """@echo off
"""
# Validate all the manifests before starting
internal_app_validate_result = validate_app_list(internal_app_list)
user_app_validate_result = validate_app_list(user_app_list)
# Install apps
internal_apps = install_app_list(app_list=internal_app_list,
download_dir=download_dir,
install_dir=install_dir,
is_windows=is_windows)
user_apps = install_app_list(app_list=user_app_list,
download_dir=download_dir,
install_dir=install_dir,
is_windows=is_windows)
# Write the devenv script with environment variables
if is_windows:
devenv_script_buffer += "set devenver_root_backslash=%~dp0\n"
devenv_script_buffer += "set devenver_root=%devenver_root_backslash:~0,-1%\n"
devenv_script_buffer += "set devenver_root_backslash=\n"
devenv_script_buffer += "set path=%~dp0Symlinks;%PATH%\n"
devenv_script_buffer += "set path=%~dp0Scripts;%PATH%\n"
else:
devenv_script_buffer += f"export devenver_root=\"$( cd -- $( dirname -- \"${{BASH_SOURCE[0]}}\" ) &> /dev/null && pwd )\"\n"
devenv_script_buffer += f"PATH=\"$( cd -- $( dirname -- \"${{BASH_SOURCE[0]}}\" ) &> /dev/null && pwd )/Scripts\":$PATH\n"
devenv_script_buffer += f"PATH=\"$( cd -- $( dirname -- \"${{BASH_SOURCE[0]}}\" ) &> /dev/null && pwd )/Symlinks\":$PATH\n"
devenv_script_buffer += f"PATH=$(echo $PATH | awk -v RS=: -v ORS=: '/^\/mnt\/c/ {{next}} {{print}}')\n"
devenv_script_buffer += f"source $devenver_root/unix_fzf-completion.bash\n"
devenv_script_buffer += f"source $devenver_root/unix_fzf-key-bindings.bash\n"
devenv_script_name = f"{devenv_script_name}.bat" if is_windows else f"{devenv_script_name}.sh"
devenv_script_path = pathlib.Path(install_dir, devenv_script_name)
lprint(f"Writing script to augment the environment with installed applications: {devenv_script_path}")
devenv_script_path.write_text(devenv_script_buffer)
if not is_windows:
subprocess.run(args=["chmod", "+x", devenv_script_path])
# Merge the install dictionaries, this dictionary contains
# (app label) -> [array of installed versions]
result = internal_apps
for key, value in user_apps.items():
if key not in result:
result.update({key: value})
else:
result[key] += value
return result