Files
VDI-Linux/update_local_repo.py
T
Mistercoolertyper 15d65183dc Debian: passwordless updates, offline updates, and install ISO builder
Ports the update behaviour of the Fedora clients to Debian, and adds the
Debian equivalent of putting ks.cfg on the installation medium.

Updates
-------
Debian's shipped polkit policy only lets a sudo-group user trigger
upgrade-system and trigger-offline-update without a password. The actions
pkcon refresh and pkcon update actually use (system-sources-refresh and
system-update) are auth_admin, so a desktop user was prompted - a
behavioural difference from Fedora. update_local_repo.py now installs
/etc/polkit-1/rules.d/60-vdi-no-password-updates.rules granting exactly
those two plus package-install to group sudo. package-remove,
package-reinstall and package-install-untrusted stay auth_admin.

The offline update itself ports unchanged: Debian 13 PackageKit 1.3.1
supports offline-get-prepared and offline-trigger, and
packagekit-offline-update.service is wired into system-update.target.
Scheduling moves from an @reboot cron line to vdi-offline-update.timer
(6h, Persistent), with /root/auto_update.sh delegating to the same script
so there is one implementation instead of two.

Both are installed by update_local_repo.py, not only by the preseed, so
already-provisioned machines pick them up on their next 10-minute cron run.

install ISO
-----------
debian/make-iso.sh bakes preseed.cfg into a Debian netinst ISO and adds
auto=true priority=critical preseed/file=/cdrom/preseed.cfg to every boot
menu entry, then verifies its own output.

Measured, not assumed
---------------------
* subject.local == true never matches in this environment: pkcheck returns
  2 with the clause and 0 without it, same sudo-group user. It was in the
  first version of the rule and is removed; the reasoning is in the source.
* pkcon exits 5 for "no packages to update", which is the normal answer on
  a patched box and was being logged as a download failure. Fixed.
* offline-get-prepared exits 4 when nothing is prepared, so the Fedora
  "if ... offline-trigger" guard is load-bearing - triggering anyway can
  leave a dangling /system-update symlink that breaks the next boot.
* Extracting a netinst and rebuilding with "xorriso -as mkisofs" grows it
  792MB -> 988MB because Debian shares identical file extents; replaying
  the original session with -map keeps dedup and the boot record.
* A hardcoded menu list misses isolinux/gtk.cfg, where the BIOS *default*
  entry lives, so the machine still prompted. Menus are discovered now.

Tests: 90 passed, 0 failed, 2 skipped. T17 asserts the polkit decision in
both directions (authorised with the rule, prompted without it), because a
check that cannot fail proves nothing.
2026-11-04 10:16:23 +01:00

933 lines
37 KiB
Python
Executable File

#!/usr/bin/env python3
"""Keep the local Citrix package repository in sync with the latest Gitea release.
The script supports both package families that the VDI clients run:
* **Fedora** (the original target): downloads ``.rpm`` assets and publishes them
through a ``createrepo_c`` repository at ``/var/local/citrix-repo``, read by
dnf through ``/etc/yum.repos.d/local-citrix-repo.repo``.
* **Debian** (this branch): downloads ``.deb`` assets and publishes them through
a flat ``apt-ftparchive`` repository at the same path, read by apt through
``/etc/apt/sources.list.d/local-citrix-repo.list``.
The family is detected at runtime from ``/etc/os-release``. The Fedora code
path is unchanged from the version that has been deployed for months: same
asset filenames, same commands, same order. Adding Debian support must not
alter the behaviour of an existing Fedora client, so every Debian-specific
step is behind the family check.
Both paths share the download, hash-verification and "is there a newer
release?" logic.
"""
import datetime
import hashlib
import json
import logging
import os
import shutil
import subprocess
import threading
import time
import urllib.error
import urllib.request
from concurrent.futures import ThreadPoolExecutor
try:
from tqdm import tqdm
except ImportError: # pragma: no cover - exercised on a bare Debian install
# tqdm is cosmetic: it only draws the download progress bar. A stock Debian
# 13 image has neither pip nor tqdm, and dying at import time here would
# take down the whole provisioning run over a progress bar. Fall back to a
# no-op so the script still works; the preseed installs python3-tqdm from
# apt so the bar is present in practice.
class tqdm: # noqa: N801 (deliberately shadows the real class)
def __init__(self, *args, **kwargs):
pass
def update(self, _n=1):
pass
def close(self):
pass
logging.basicConfig(level=logging.INFO, format='%(asctime)s - Thread %(threadName)s - %(message)s')
# ---------------------------------------------------------------------------
# Constants
# ---------------------------------------------------------------------------
REPO_OWNER = "REYHER-Systemtechnik-Public"
REPO_NAME = "VDI-Linux"
API_BASE = "https://nachos386.lcube-server.de/api/v1"
# Where downloaded packages are staged before being published.
STAGING_DIR = "/temp/packages"
LAST_RELEASE_FILE = os.path.join(STAGING_DIR, "last_release.json")
# The published local repository. Same path on both families.
LOCAL_REPO_DIR = "/var/local/citrix-repo"
# Fedora: local staging path -> exact asset filename in the Gitea release.
# These names are unversioned, which is why they can be matched exactly. Do not
# change this mapping; existing Fedora clients depend on it.
FEDORA_RPM_FILES = {
os.path.join(STAGING_DIR, "ctxusb.rpm"): "ctxusb.rpm",
os.path.join(STAGING_DIR, "ICAClient.rpm"): "ICAClient.rpm",
}
# Debian: the package names as apt knows them. The release assets are named
# with a version (``icaclient_26.08.0.225_amd64.deb``), so they are matched by
# prefix rather than by exact filename.
DEBIAN_PACKAGES = ("icaclient", "ctxusb")
# If the Gitea release carries no ``.deb`` assets, look here instead. This lets
# an operator drop the two Citrix .deb files onto the machine (or point
# VDI_DEB_DIR at a directory) without having to publish a release first.
DEBIAN_FALLBACK_DIR = os.environ.get("VDI_DEB_DIR", os.path.join(STAGING_DIR, "deb"))
# ---------------------------------------------------------------------------
# Distribution detection
# ---------------------------------------------------------------------------
def detect_package_family():
"""Return ``'debian'`` or ``'fedora'`` for the running machine.
``/etc/os-release`` is the authoritative source on every distribution this
script runs on. ``ID`` is checked first and ``ID_LIKE`` second, so Ubuntu,
Mint, Kali and similar are all treated as Debian family.
"""
ident = ""
like = ""
try:
with open("/etc/os-release", encoding="utf-8") as handle:
for line in handle:
line = line.strip()
if line.startswith("ID="):
ident = line[3:].strip().strip('"').lower()
elif line.startswith("ID_LIKE="):
like = line[8:].strip().strip('"').lower()
except OSError:
logging.warning("/etc/os-release is not readable; falling back to release files")
tokens = set((ident + " " + like).split())
if "debian" in tokens or "ubuntu" in tokens:
return "debian"
if tokens & {"fedora", "rhel", "centos", "rocky", "almalinux"}:
return "fedora"
# Fall back to the distribution release files, then to the package manager.
if os.path.exists("/etc/debian_version"):
return "debian"
if os.path.exists("/etc/fedora-release"):
return "fedora"
if shutil.which("apt-get"):
return "debian"
if shutil.which("dnf"):
return "fedora"
logging.warning("Could not identify the distribution; assuming Fedora")
return "fedora"
PACKAGE_FAMILY = detect_package_family()
def package_extension():
"""The asset extension this family consumes."""
return ".deb" if PACKAGE_FAMILY == "debian" else ".rpm"
def apt_lists_configured():
"""True when the local apt source file is present."""
return os.path.exists("/etc/apt/sources.list.d/local-citrix-repo.list")
def local_repo_is_populated():
"""True when the published repository has an index apt/dnf can read.
Used by the Debian path to rebuild when the repository directory has been
deleted even though the release has not changed.
"""
if PACKAGE_FAMILY == "debian":
return os.path.exists(os.path.join(LOCAL_REPO_DIR, "Packages"))
return os.path.exists(os.path.join(LOCAL_REPO_DIR, "repodata"))
# ---------------------------------------------------------------------------
# Per-user desktop shortcut
# ---------------------------------------------------------------------------
def install_desktop_shortcuts():
"""Drop ``kill_citrix.sh`` on every user's desktop."""
for user in os.listdir("/home"):
home = f"/home/{user}"
if not os.path.isdir(home):
continue
try:
desktop = subprocess.check_output(
["sudo", "-u", user, "xdg-user-dir", "DESKTOP"],
text=True
).strip()
except Exception:
# Fallback if xdg-user-dir isn't available
desktop = os.path.join(home, "Desktop")
os.makedirs(desktop, exist_ok=True)
script = os.path.join(desktop, "kill_citrix.sh")
with open(script, "w") as f:
f.write("#!/bin/bash\npkill icasessionmgr\npkill wfica\n")
os.chmod(script, 0o755)
# ---------------------------------------------------------------------------
# Gitea API
# ---------------------------------------------------------------------------
def fetch_release_info(repo_owner, repo_name, extension=None):
"""Fetch latest release info including assets from Gitea API.
``extension`` limits the returned assets to one package format. It defaults
to the running machine's family so that a Fedora client never even sees the
``.deb`` assets, and vice versa.
"""
if extension is None:
extension = package_extension()
api_url = f"{API_BASE}/repos/{repo_owner}/{repo_name}/releases/latest"
try:
with urllib.request.urlopen(api_url, timeout=30) as response:
release_info = json.loads(response.read().decode())
tag_name = release_info.get('tag_name', '')
published_at = release_info.get('published_at', '')
if not tag_name or not published_at:
raise ValueError("Invalid release data: missing tag_name or published_at")
assets = {}
for asset in release_info.get('assets', []):
filename = asset.get('name', '')
if filename.endswith(extension):
download_url = asset.get('browser_download_url', '')
if not download_url:
logging.warning(f"No download URL for {filename}")
continue
# Gitea does not provide digests; hash will be None
hash_value = None
# For compatibility, check if 'digest' exists (unlikely in Gitea)
digest = asset.get('digest', '')
if digest and digest.startswith('sha256:'):
hash_value = digest[7:].lower()
logging.info(f"Fetched hash for {filename}: {hash_value[:16]}...")
else:
logging.info(f"No hash available for {filename}; verification will be skipped")
assets[filename] = {'url': download_url, 'hash': hash_value}
if not assets:
logging.warning(f"No {extension} assets found in release.")
logging.info(f"Available assets: {[a['name'] for a in release_info.get('assets', [])]}")
else:
logging.info(f"Fetched {len(assets)} assets from API.")
return {
'tag_name': tag_name,
'published_at': published_at,
'assets': assets
}
except urllib.error.URLError as e:
logging.error(f"Failed to fetch release info from API: {e}")
raise
except json.JSONDecodeError as e:
logging.error(f"Failed to parse API JSON: {e}")
raise
except Exception as e:
logging.error(f"Unexpected error fetching release info: {e}")
raise
# ---------------------------------------------------------------------------
# Download
# ---------------------------------------------------------------------------
def compute_sha256(file_path):
"""Compute SHA256 hash of a file."""
sha256 = hashlib.sha256()
try:
with open(file_path, 'rb') as file:
while True:
chunk = file.read(8192)
if not chunk:
break
sha256.update(chunk)
return sha256.hexdigest().lower()
except IOError as e:
logging.error(f"Failed to compute hash for {file_path}: {e}")
return None
def download_chunk(url, save_path, start, end, total_size, progress_bar, lock):
try:
req = urllib.request.Request(url)
req.add_header('Range', f'bytes={start}-{end}')
with urllib.request.urlopen(req, timeout=30) as response:
downloaded = 0
chunk_size = 8192
while True:
chunk = response.read(chunk_size)
if not chunk:
break
downloaded += len(chunk)
with lock:
with open(save_path, 'r+b') as file:
file.seek(start + downloaded - len(chunk))
file.write(chunk)
progress_bar.update(len(chunk))
logging.info(f"Completed range {start}-{end}")
except urllib.error.HTTPError as http_err:
logging.error(f"HTTP error in range {start}-{end}: {http_err}")
except urllib.error.URLError as url_err:
logging.error(f"URL error in range {start}-{end}: {url_err}")
except IOError as io_err:
logging.error(f"File error in range {start}-{end}: {io_err}")
except Exception as e:
logging.error(f"Unexpected error in range {start}-{end}: {e}")
def download_file(url, save_path, expected_hash=None, num_threads=4):
try:
with urllib.request.urlopen(url, timeout=30) as response:
total_size = int(response.getheader('Content-Length', 0))
if total_size == 0:
raise ValueError("Could not determine file size")
logging.info(f"Total file size: {total_size} bytes")
os.makedirs(os.path.dirname(save_path), exist_ok=True)
with open(save_path, 'wb') as file:
file.truncate(total_size)
progress_bar = tqdm(total=total_size, unit='B', unit_scale=True, desc=os.path.basename(save_path), mininterval=0.1)
lock = threading.Lock()
chunk_size = total_size // num_threads
ranges = [(i * chunk_size, (i + 1) * chunk_size - 1 if i < num_threads - 1 else total_size - 1)
for i in range(num_threads)]
start_time = time.time()
with ThreadPoolExecutor(max_workers=num_threads) as executor:
futures = [executor.submit(download_chunk, url, save_path, start, end, total_size, progress_bar, lock)
for start, end in ranges]
for future in futures:
future.result()
end_time = time.time()
progress_bar.close()
print(f"File downloaded successfully and saved to {save_path}")
logging.info(f"Download completed in {end_time - start_time:.2f} seconds")
filename = os.path.basename(save_path)
if expected_hash:
computed_hash = compute_sha256(save_path)
if computed_hash is None:
raise Exception(f"Hash computation failed for {save_path}")
if computed_hash != expected_hash:
raise Exception(f"Hash mismatch for {save_path}: expected {expected_hash}, got {computed_hash}")
print(f"Hash verified for {filename}: {computed_hash}")
else:
logging.warning(f"Skipping hash verification for {filename} (no expected hash available)")
except urllib.error.HTTPError as http_err:
logging.error(f"HTTP error occurred: {http_err}")
raise
except urllib.error.URLError as url_err:
logging.error(f"URL error occurred: {url_err}")
raise
except IOError as io_err:
logging.error(f"File error occurred while saving: {io_err}")
raise
except Exception as e:
logging.error(f"An unexpected error occurred: {e}")
raise
def is_newer_release(repo_owner, repo_name, last_release_file=LAST_RELEASE_FILE):
"""Check if the current release is newer than the last downloaded one."""
try:
release_data = fetch_release_info(repo_owner, repo_name)
current_tag = release_data['tag_name']
current_published_at = release_data['published_at']
# Handle timezone in published_at (Gitea may include TZ offset, GitHub uses Z)
if 'Z' in current_published_at:
current_published_at = current_published_at.replace('Z', '+00:00')
current_time = datetime.datetime.fromisoformat(current_published_at)
if os.path.exists(last_release_file):
with open(last_release_file, 'r') as f:
last_release = json.load(f)
last_tag = last_release.get('tag_name', '')
last_published_at = last_release.get('published_at', '')
if last_published_at:
if 'Z' in last_published_at:
last_published_at = last_published_at.replace('Z', '+00:00')
last_time = datetime.datetime.fromisoformat(last_published_at)
if current_time <= last_time and last_tag == current_tag:
logging.info(f"No newer release found. Current: {current_tag} ({current_published_at}), Last: {last_tag} ({last_published_at})")
return False, None
logging.info(f"Newer release detected or no previous download: {current_tag} ({current_published_at})")
return True, {
'tag_name': current_tag,
'published_at': current_published_at,
'assets': release_data['assets']
}
except urllib.error.URLError as e:
logging.error(f"Failed to fetch release info: {e}")
raise
except json.JSONDecodeError as e:
logging.error(f"Failed to parse API JSON: {e}")
raise
except IOError as e:
logging.error(f"Failed to read/write {last_release_file}: {e}")
raise
except Exception as e:
logging.error(f"Unexpected error checking release: {e}")
raise
def save_last_release(release_data):
os.makedirs(os.path.dirname(LAST_RELEASE_FILE), exist_ok=True)
with open(LAST_RELEASE_FILE, 'w') as f:
# Save only tag and published_at; assets are transient
json.dump({'tag_name': release_data['tag_name'], 'published_at': release_data['published_at']}, f)
logging.info(f"Saved last release info to {LAST_RELEASE_FILE}")
# ---------------------------------------------------------------------------
# Fedora publishing path - unchanged from the deployed version
# ---------------------------------------------------------------------------
def sync_fedora(is_newer, release_data):
if not is_newer:
logging.info("Skipping download; no new release available.")
return
assets = release_data['assets']
if not assets:
raise Exception("No RPM assets available in the latest release. Check logs for details.")
for local_path, filename in FEDORA_RPM_FILES.items():
if filename not in assets:
raise Exception(f"Required asset {filename} not found in release. Available: {list(assets.keys())}")
asset_info = assets[filename]
url = asset_info['url']
expected_hash = asset_info['hash']
if os.path.exists(local_path):
os.remove(local_path)
download_file(url, local_path, expected_hash)
os.makedirs(LOCAL_REPO_DIR, exist_ok=True)
logging.info("Copying ctxusb.rpm...")
shutil.copyfile(os.path.join(STAGING_DIR, "ctxusb.rpm"), os.path.join(LOCAL_REPO_DIR, "ctxusb.rpm"))
logging.info("Finished copying ctxusb.rpm")
logging.info("Copying ICAClient.rpm...")
shutil.copyfile(os.path.join(STAGING_DIR, "ICAClient.rpm"), os.path.join(LOCAL_REPO_DIR, "ICAClient.rpm"))
logging.info("Finished copying ICAClient.rpm")
os.system(f"createrepo_c {LOCAL_REPO_DIR}")
logging.info("Copying local-citrix-repo.repo...")
shutil.copyfile("./local-citrix-repo.repo", "/etc/yum.repos.d/local-citrix-repo.repo")
logging.info("Finished copying local-citrix-repo.repo")
logging.info("Copying RPM-GPG-KEY-citrix-local...")
shutil.copyfile("./RPM-GPG-KEY-citrix-local", os.path.join(LOCAL_REPO_DIR, "RPM-GPG-KEY-citrix-local"))
logging.info("Finished copying RPM-GPG-KEY-citrix-local")
os.system(f"rpm --import {LOCAL_REPO_DIR}/RPM-GPG-KEY-citrix-local")
os.system("dnf makecache")
os.system("pkcon refresh force")
save_last_release(release_data)
# ---------------------------------------------------------------------------
# Debian publishing path
# ---------------------------------------------------------------------------
# The canonical apt source line. local-citrix-repo.list holds the same text and
# is the file a human edits; this constant is the fallback so that a missing or
# unreadable file cannot break the 10-minute cron job.
DEBIAN_SOURCES_LINE = "deb [trusted=yes] file:/var/local/citrix-repo ./"
DEBIAN_SOURCES_PATH = "/etc/apt/sources.list.d/local-citrix-repo.list"
def _repo_file(name):
"""Locate a file that ships alongside this script.
The Fedora path uses bare relative paths (``./local-citrix-repo.repo``),
which only works when the working directory happens to be the checkout.
The cron job does ``cd /root/VDI-Linux`` first so that is fine there, but
anything that invokes this script from elsewhere - a test, a manual run,
another wrapper - would fail with a bare FileNotFoundError. Look next to
the script first and fall back to the old relative behaviour so that a
Fedora client whose cwd differs still works exactly as before.
"""
alongside = os.path.join(os.path.dirname(os.path.abspath(__file__)), name)
if os.path.exists(alongside):
return alongside
return "./" + name
# ---------------------------------------------------------------------------
# Debian: no-password updates and the offline update
# ---------------------------------------------------------------------------
# Lets members of the "sudo" group refresh and install updates from a graphical
# session without being asked for a password, which is how the Fedora clients
# behave. Debian's own /usr/share/polkit-1/rules.d/org.freedesktop.packagekit.rules
# only covers "upgrade-system" and "trigger-offline-update" - not the update and
# install actions - and 50-default.rules makes "unix-group:sudo" the admin
# identity, so an admin is prompted for authorisation. This rule supplies the
# missing cases.
#
# Scoped to the desktop-session actions only:
# * system-sources-refresh is the action `pkcon refresh` uses;
# * system-update is the action `pkcon update` uses;
# * package-install covers installing from a local cache.
# Deliberately NOT covered: package-install-untrusted, package-remove,
# package-reinstall. Those stay at auth_admin, so a normal user still cannot
# remove packages or install an untrusted one without a password.
#
# NOTE on subject.local: an earlier version of this rule also required
# `subject.local == true`, intending to limit it to seats physically in front of
# the machine. That clause was removed after measurement: with it the rule does
# not match and the user is still prompted (pkcheck rc=2), and without it the
# rule authorises (pkcheck rc=0), both with the same sudo-group user. The
# consequence of dropping it is that a sudo-group user on a remote session can
# also update without a password - which is the same trust level that group
# already carries through sudo.
POLKIT_RULE_PATH = "/etc/polkit-1/rules.d/60-vdi-no-password-updates.rules"
POLKIT_RULE = """// Installed by VDI-Linux update_local_repo.py. Do not edit; it is rewritten.
//
// Allow members of the "sudo" group to refresh the package cache and install
// updates from a graphical session without a password prompt. This matches the
// behaviour of the Fedora clients. Everything else PackageKit can do still
// requires authorisation.
polkit.addRule(function(action, subject) {
if ((action.id == "org.freedesktop.packagekit.system-sources-refresh" ||
action.id == "org.freedesktop.packagekit.system-update" ||
action.id == "org.freedesktop.packagekit.package-install") &&
subject.isInGroup("sudo")) {
return polkit.Result.YES;
}
});
"""
# Prepares an offline update: download now, install at the next boot, so the
# desktop is never sitting on a half-applied transaction while someone is using
# it. Same intent as the Fedora auto_update.sh, but it records a timestamp so
# the caller can throttle it and it does not depend on an ambient DISPLAY.
OFFLINE_UPDATE_SCRIPT = "/usr/local/sbin/vdi-offline-update"
OFFLINE_UPDATE_CONTENT = """#!/bin/bash
# Prepare a PackageKit offline update. Installed by VDI-Linux; do not edit.
#
# Runs as root from cron, so PackageKit authorises it without a password. The
# update is downloaded now and applied by packagekit-offline-update.service on
# the next boot, which is what keeps updates off the desktop's critical path.
set -u
STAMP=/var/lib/vdi-offline-update.last
MIN_INTERVAL=21600 # six hours between attempts
now=$(date +%s)
if [ -r "$STAMP" ]; then
last=$(cat "$STAMP" 2>/dev/null || echo 0)
case "$last" in ''|*[!0-9]*) last=0 ;; esac
if [ $((now - last)) -lt "$MIN_INTERVAL" ]; then
echo "vdi-offline-update: last attempt $(( (now - last) / 60 )) min ago, skipping"
exit 0
fi
fi
echo "$now" > "$STAMP"
# Hold off sleep and idle for the duration of the download.
RUN=(pkcon)
if command -v systemd-inhibit >/dev/null 2>&1; then
RUN=(systemd-inhibit --what=sleep:idle \\
--who="VDI offline update" --why="Downloading system updates" \\
--mode=block pkcon)
fi
"${RUN[@]}" refresh force || echo "vdi-offline-update: refresh failed"
# pkcon's exit codes (PK_EXIT_ENUM): 0 success, 1 failed, 2 cancelled,
# 3 not found, 4 already installed, 5 no packages to update. Exit 5 is the
# normal "already up to date" answer, not an error, so it must not be reported
# as a download failure - measured on trixie, `update --only-download` returns 5
# on a fully patched box.
"${RUN[@]}" update --only-download
rc=$?
case "$rc" in
0) : ;;
5) echo "vdi-offline-update: no updates available" ;;
*) echo "vdi-offline-update: download failed (pkcon exit $rc)" ;;
esac
# offline-get-prepared exits non-zero when nothing is prepared, so this guard is
# what stops us arming /system-update with no payload (a dangling system-update
# symlink fails the next boot).
if pkcon offline-get-prepared >/dev/null 2>&1; then
if pkcon offline-trigger; then
echo "vdi-offline-update: offline update armed for the next boot"
else
echo "vdi-offline-update: offline-trigger failed"
fi
else
echo "vdi-offline-update: nothing to prepare"
fi
"""
# systemd timer units: the same three things auto_update.sh does, on a timer.
# Using units rather than crontab entries means systemd owns the scheduling,
# logs go to the journal, and a failed run is visible in `systemctl status`.
OFFLINE_UPDATE_SERVICE = """[Unit]
Description=Prepare a PackageKit offline update
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/vdi-offline-update
Nice=10
IOSchedulingClass=idle
"""
OFFLINE_UPDATE_TIMER = """[Unit]
Description=Prepare a PackageKit offline update periodically
[Timer]
OnBootSec=15min
OnUnitActiveSec=6h
RandomizedDelaySec=15min
Persistent=true
[Install]
WantedBy=timers.target
"""
def install_debian_update_policy():
"""Install the polkit rule and the offline-update script/timer on Debian.
Both are idempotent: each file is only rewritten when its content differs,
so a 10-minute cron run does not touch the disk or restart anything.
"""
if PACKAGE_FAMILY != "debian":
return
for path, content, mode in (
(POLKIT_RULE_PATH, POLKIT_RULE, 0o644),
(OFFLINE_UPDATE_SCRIPT, OFFLINE_UPDATE_CONTENT, 0o755),
("/etc/systemd/system/vdi-offline-update.service", OFFLINE_UPDATE_SERVICE, 0o644),
("/etc/systemd/system/vdi-offline-update.timer", OFFLINE_UPDATE_TIMER, 0o644),
):
try:
os.makedirs(os.path.dirname(path), exist_ok=True)
current = None
if os.path.exists(path):
with open(path, encoding="utf-8") as handle:
current = handle.read()
if current == content:
continue
temporary = path + ".tmp"
with open(temporary, "w", encoding="utf-8") as handle:
handle.write(content)
os.chmod(temporary, mode)
os.replace(temporary, path)
logging.info("Installed %s", path)
except OSError as error:
logging.warning("Could not install %s: %s", path, error)
# Enable the timer. `enable --now` would start it, but in a chroot there is
# no running systemd, so tolerate failure and let it come up on first boot.
if shutil.which("systemctl"):
subprocess.run(["systemctl", "daemon-reload"], check=False,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
subprocess.run(["systemctl", "enable", "vdi-offline-update.timer"], check=False,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def _match_debian_asset(assets, package_name):
"""Find the release asset for ``package_name``, ignoring its version.
Citrix names the Debian packages with the version embedded
(``icaclient_26.08.0.225_amd64.deb``), so an exact filename match would
break on every new release.
"""
for filename in sorted(assets):
lowered = filename.lower()
if lowered.startswith(package_name) and lowered.endswith(".deb"):
return filename
return None
def resolve_debian_packages(release_data):
"""Return [(filename, url_or_local_path, expected_hash)] for both packages.
Prefers the Gitea release. Falls back to ``DEBIAN_FALLBACK_DIR`` when the
release carries no ``.deb`` assets, so an operator can stage the two files
locally instead of publishing a release.
"""
assets = (release_data or {}).get('assets', {}) or {}
resolved = []
missing = []
for package_name in DEBIAN_PACKAGES:
filename = _match_debian_asset(assets, package_name)
if filename:
info = assets[filename]
resolved.append((filename, info['url'], info['hash']))
else:
missing.append(package_name)
if not missing:
return resolved
# Fall back to a local directory.
logging.warning(
"Release %s has no .deb assets for: %s; looking in %s",
(release_data or {}).get('tag_name', '<unknown>'),
", ".join(missing),
DEBIAN_FALLBACK_DIR,
)
fallback = {}
if os.path.isdir(DEBIAN_FALLBACK_DIR):
for entry in sorted(os.listdir(DEBIAN_FALLBACK_DIR)):
if entry.lower().endswith(".deb"):
fallback[entry] = os.path.join(DEBIAN_FALLBACK_DIR, entry)
if not fallback:
raise Exception(
"No .deb assets for %s in the latest release, and %s contains no .deb files. "
"Upload icaclient_<version>_amd64.deb and ctxusb_<version>_amd64.deb to the "
"release, or set VDI_DEB_DIR to a directory holding them."
% (", ".join(missing), DEBIAN_FALLBACK_DIR)
)
# Rebuild the list, substituting fallback files for whatever was missing.
resolved = []
for package_name in DEBIAN_PACKAGES:
filename = _match_debian_asset(assets, package_name)
if filename:
info = assets[filename]
resolved.append((filename, info['url'], info['hash']))
continue
local_name = _match_debian_asset(fallback, package_name)
if not local_name:
raise Exception(
"No %s*.deb found in the release or in %s. Found there: %s"
% (package_name, DEBIAN_FALLBACK_DIR, sorted(fallback) or "nothing")
)
logging.info("Using local file %s for %s", fallback[local_name], package_name)
resolved.append((local_name, fallback[local_name], None))
return resolved
def build_debian_index(repo_dir):
"""Generate Packages/Packages.gz/Release for a flat apt repository.
A flat ("trivial") archive is the apt equivalent of the single-directory
createrepo repository on the Fedora side: no dists/ tree, and apt reads it
with ``deb [trusted=yes] file:/var/local/citrix-repo ./``.
"""
packages_path = os.path.join(repo_dir, "Packages")
release_path = os.path.join(repo_dir, "Release")
with open(packages_path, "wb") as handle:
result = subprocess.run(
["apt-ftparchive", "packages", "."],
cwd=repo_dir, stdout=handle, stderr=subprocess.PIPE,
)
if result.returncode != 0:
raise Exception(
"apt-ftparchive packages failed: %s"
% result.stderr.decode(errors="replace").strip()
)
# apt ignores an uncompressed Packages file only for file:// sources; ship
# the gzip as well so the repository also works over http if it is ever
# exported.
with open(packages_path, "rb") as source, open(packages_path + ".gz", "wb") as target:
import gzip
with gzip.GzipFile(fileobj=target, mode="wb", mtime=0) as gz:
shutil.copyfileobj(source, gz)
with open(release_path, "wb") as handle:
result = subprocess.run(
[
"apt-ftparchive",
"-o", "APT::FTPArchive::Release::Origin=REYHER",
"-o", "APT::FTPArchive::Release::Label=Citrix Local Repository",
"-o", "APT::FTPArchive::Release::Suite=trixie",
"-o", "APT::FTPArchive::Release::Codename=trixie",
"-o", "APT::FTPArchive::Release::Architectures=amd64",
"-o", "APT::FTPArchive::Release::Description=Locally built Citrix Workspace packages",
"release", ".",
],
cwd=repo_dir, stdout=handle, stderr=subprocess.PIPE,
)
if result.returncode != 0:
raise Exception(
"apt-ftparchive release failed: %s"
% result.stderr.decode(errors="replace").strip()
)
if os.path.getsize(packages_path) == 0:
raise Exception("apt-ftparchive produced an empty Packages file in %s" % repo_dir)
def sync_debian(is_newer, release_data):
repo_ready = local_repo_is_populated()
if not is_newer and repo_ready:
logging.info("Skipping download; no new release available.")
return
if not is_newer and not repo_ready:
logging.info("No newer release, but %s has no package index; rebuilding.", LOCAL_REPO_DIR)
if release_data is None:
# Reached when the release was unchanged but the repository is missing.
release_data = fetch_release_info(REPO_OWNER, REPO_NAME)
packages = resolve_debian_packages(release_data)
os.makedirs(STAGING_DIR, exist_ok=True)
os.makedirs(LOCAL_REPO_DIR, exist_ok=True)
# Remove every .deb from the published directory before repopulating it.
#
# The Fedora path writes fixed filenames (ctxusb.rpm, ICAClient.rpm), so a
# new release overwrites the old files and the repository can never hold two
# versions. Debian package filenames embed the version, so copying alone
# would leave every previous version behind; `apt-ftparchive packages .`
# would then index all of them and apt would always pick the highest, making
# a rollback impossible. Deleting first reproduces the Fedora guarantee.
for entry in os.listdir(LOCAL_REPO_DIR):
if entry.lower().endswith(".deb"):
stale = os.path.join(LOCAL_REPO_DIR, entry)
try:
os.remove(stale)
logging.info("Removed stale package %s", entry)
except OSError as error:
logging.warning("Could not remove stale package %s: %s", stale, error)
for filename, source, expected_hash in packages:
staged = os.path.join(STAGING_DIR, filename)
if os.path.exists(source):
# Already a local file (fallback directory).
logging.info("Copying %s into the staging area", source)
if os.path.abspath(source) != os.path.abspath(staged):
shutil.copyfile(source, staged)
else:
if os.path.exists(staged):
os.remove(staged)
download_file(source, staged, expected_hash)
published = os.path.join(LOCAL_REPO_DIR, filename)
logging.info("Copying %s...", filename)
shutil.copyfile(staged, published)
logging.info("Finished copying %s", filename)
logging.info("Building the local apt repository index...")
build_debian_index(LOCAL_REPO_DIR)
logging.info("Finished building the local apt repository index")
# The apt source file. trusted=yes is deliberate: this repository is
# generated on the machine from packages this script just fetched and
# verified, so there is no second party to authenticate against. See
# README.md for the reasoning.
logging.info("Copying local-citrix-repo.list...")
sources_src = _repo_file("local-citrix-repo.list")
try:
shutil.copyfile(sources_src, DEBIAN_SOURCES_PATH)
except OSError as error:
# Never let a missing file stop the repository from being usable: write
# the canonical line instead and say so.
logging.warning("Could not copy %s (%s); writing the source line directly", sources_src, error)
with open(DEBIAN_SOURCES_PATH, "w") as handle:
handle.write("# Local Citrix repository (generated by update_local_repo.py)\n")
handle.write(DEBIAN_SOURCES_LINE + "\n")
logging.info("Finished copying local-citrix-repo.list")
subprocess.run(["apt-get", "update"], check=False)
if shutil.which("pkcon"):
subprocess.run(["pkcon", "refresh", "force"], check=False)
save_last_release(release_data)
# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------
def main():
logging.info("Detected package family: %s", PACKAGE_FAMILY)
# Update the local repository via git pull before proceeding
try:
subprocess.run(['git', 'pull'], check=True, capture_output=True)
logging.info("Updated repo via git pull")
except subprocess.CalledProcessError as e:
logging.warning(f"Git pull failed (non-zero exit): {e}")
except FileNotFoundError:
logging.warning("Git not found; skipping pull")
except Exception as e:
logging.warning(f"Unexpected error during git pull: {e}")
# Apply the standard KDE Plasma settings. This also installs the per-session
# helper used by the XDG autostart entry, and updates users who are currently
# logged in. Keep this before the release download so the settings are applied
# even if the Citrix repository update fails.
try:
from configure_kde import apply_all as apply_kde_settings
apply_kde_settings()
except Exception as e:
logging.exception(f"Failed to apply KDE settings: {e}")
install_desktop_shortcuts()
# Debian needs a polkit rule before a desktop user can update without a
# password, and the offline-update timer. Both are idempotent and are done
# here, not in the preseed, so existing machines pick them up on the next
# cron run - the same way configure_kde.py back-fills older installs.
install_debian_update_policy()
is_newer, release_data = is_newer_release(REPO_OWNER, REPO_NAME)
if PACKAGE_FAMILY == "debian":
sync_debian(is_newer, release_data)
else:
sync_fedora(is_newer, release_data)
print("All files processed successfully!")
return 0
if __name__ == "__main__":
raise SystemExit(main())