oSoWoSo/DistroHopper
1
0
Fork 0
mirror of https://github.com/oSoWoSo/DistroHopper.git synced 2026-06-14 09:32:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
DistroHopper/qget
zenobit c4fcb6ff91 Prepare release and new website
2026-05-27 17:00:06 +02:00

929 lines
24 KiB
Bash
Executable file
Raw Permalink Blame History

#!/usr/bin/env bash
# SC2317: Command appears to be unreachable. Check usage (or ignore if invoked indirectly).
# - https://www.shellcheck.net/wiki/SC2317
# - Disable globally because many functions are called indirectly
# shellcheck disable=SC2317
# shellcheck source=../lib.sh
SCRIPT_DIR="$(dirname "$(realpath "$0")")"
source "${SCRIPT_DIR}/lib.sh"
# Latest cherrypick (or not) commit. Start from here...
# https://github.com/quickemu-project/quickemu/tree/3da9edc9953340622db23be4661aefa4cd0632f2
export TEXTDOMAIN=qget
export PUBLIC_DIR="${PUBLIC_DIR:-${SCRIPT_DIR}/public}"
if [[ -n $Q_DEBUG ]]; then
export TEXTDOMAINDIR="${PWD}/locale"
else
export TEXTDOMAINDIR=/usr/share/locale
fi
export LC_ALL=C
TEMPLATES_DIR="${TEMPLATES_DIR:-${SCRIPT_DIR}/templates}"
PUBLIC_DIR="${PUBLIC_DIR:-${SCRIPT_DIR}/public}"
qgetVersion="0.8"
function cleanup() {
if [ -n "$(jobs -p)" ]; then
kill "$(jobs -p)" 2>/dev/null
fi
}
function detect_capabilities() {
#TODO: Support sixel (zellij)
HAS_CHAFA=0
HAS_NERD_FONT=0
command -v chafa >/dev/null && HAS_CHAFA=1
if command -v fc-match &>/dev/null; then
fc-match monospace 2>/dev/null | grep -qi 'nerd\|NF' && HAS_NERD_FONT=1
fi
[[ -n "${KITTY_WINDOW_ID}" || "${TERM}" == "xterm-kitty" || -n "${WEZTERM_PANE}" ]] && HAS_NERD_FONT=1
}
function show_os_info() {
# shellcheck source=public/alpine
. "${PUBLIC_DIR}/${1}"
detect_capabilities
echo
echo " ${PRETTY}"
if [[ "${HAS_CHAFA}" == "1" ]] && [[ -f "icons/${ICON}" ]]; then
chafa -s 5x5 "icons/${ICON}"
fi
local cols
cols=$(tput cols 2>/dev/null || echo 80)
echo $"Category: ${CATEGORY}"
echo $"Based of: ${BASEDOF}"
echo $"Website: ${HOMEPAGE}"
echo $"Credentials: ${CREDENTIALS}"
[ -n "${QEMU_ARCH}" ] && echo $"Archs: ${QEMU_ARCH}" | fmt -w "$cols"
echo $"Releases: ${RELEASES}" | fmt -w "$cols"
[ -n "${EDITIONS}" ] && echo $"Editions: ${EDITIONS}" | fmt -w "$cols"
[ -n "${MAGNET}" ] && echo $"Magnet: ${MAGNET}" | fmt -w "$cols"
[ -n "${CHAT}" ] && echo $"Chat: ${CHAT}"
[ -n "${RSS}" ] && echo $"RSS: ${RSS}"
[ -n "${DW}" ] && echo $"DistroWatch: ${DW}"
echo $"Description: ${DESCRIPTION}"
rosette_info "${1}"
}
function os_support() {
DIR="${PUBLIC_DIR}"
for file in "$DIR"/*; do
if [[ -f "$file" ]]; then
filename="${file##*/}"
echo "$filename"
fi
done
}
function error_specify_os() {
echo $"ERROR! You must specify an operating system."
echo $"- Supported Operating Systems:"
os_support | fmt -w $(tput cols)
echo -e $"\nTo see all possible arguments, use:\n qget -h or qget --help"
exit 1
}
function os_supported() {
#if [[ ! "$(os_support)" =~ ${OS} ]]; then
if [[ ! $'\n'"$(os_support)"$'\n' =~ $'\n'"${OS}"$'\n' ]]; then
echo -e $"ERROR! ${OS} is not a supported OS.\n"
os_support | fmt -w $(tput cols 2>/dev/null || echo 80)
exit 1
fi
}
function error_specify_release() {
. "${PUBLIC_DIR}/${OS}"
local cols
cols=$(tput cols 2>/dev/null || echo 80)
echo -e $"\nERROR! You must specify a release for ${PRETTY:-${OS}}."
echo $"Releases: ${RELEASES}" | fmt -w "$cols"
if [ -n "${EDITIONS}" ]; then
echo $"Editions: ${EDITIONS}" | fmt -w "$cols"
fi
exit 1
}
function error_not_supported_release() {
#if [[ ! "${RELEASES[*]}" =~ ${RELEASE} ]]; then
if [[ ! " ${RELEASES} " =~ " ${RELEASE} " ]]; then
echo -e $"ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release.\n"
echo -n $' - Supported releases: '
releases_
exit 1
fi
}
function error_not_supported_lang() {
echo -e $"ERROR! ${I18N} is not a supported ${PRETTY} language\n"
echo -n $' - Editions: '
for I18N in "${I18NS[@]}"; do
echo -n "${I18N} "
done
exit 1
}
function error_not_supported_argument() {
echo $"ERROR! Not supported argument"
echo $"To see all possible arguments, use:"
echo $" qget -h or qget --help"
exit 1
}
function error_unable_to_create_dir() {
echo $"ERROR! Unable to create directory ${DIR}"
exit 1
}
function error_not_supported_image() {
echo $"ERROR! Only ISO,IMG and QCOW2 file types are supported for --create-config"
exit 1
}
function is_valid_language() {
local I18N=""
local PASSED_I18N="${1}"
for I18N in "${I18NS[@]}"; do
if [[ "${I18N}" == "${PASSED_I18N}" ]]; then
return 0
fi
done
return 1
}
function handle_missing() {
# Handle odd missing Fedora combinations
case "${OS}" in
fedora)
# First we need to handle the Beta naming kludge
if [[ "${RELEASE}" == *"_Beta" ]]; then
NRELEASE="${RELEASE/_Beta/}"
else
NRELEASE="${RELEASE}"
fi
if [[ "${NRELEASE}" -lt 40 && "${EDITION}" == "Onyx" ]] || [[ "${NRELEASE}" -lt 40 && "${EDITION}" == "Sericea" ]]; then
echo $"ERROR! Unsupported combination"
echo $" Fedora ${RELEASE} ${EDITION} is not available, please choose another Release or Edition"
exit 1
fi
;;
esac
}
function validate_release() {
local DISPLAY_NAME=""
local RELEASE_GENERATOR=""
local RELEASES=""
DISPLAY_NAME="${PRETTY}"
case ${OS} in
*ubuntu-server*) RELEASE_GENERATOR="releases_";;
*ubuntu*) RELEASE_GENERATOR="releases_";;
*) RELEASE_GENERATOR="${1}";;
esac
RELEASES=$(${RELEASE_GENERATOR})
error_not_supported_release
}
function list_json() {
# Reference: https://stackoverflow.com/a/67359273
list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
exit 0
}
function list_csv() {
CSV_DATA="$(csv_data)"
echo "Display Name,OS,Release,Option,Downloader,PNG,SVG"
sort -t',' -k2,2 <<<"${CSV_DATA}"
exit 0
}
list_supported() {
# output OS RELEASE EDITION (usefull for straight testing...)
local DL=""
local FUNC
local OPTION
local OS
for OS in $(os_support); do
. "${PUBLIC_DIR}/${OS}"
for RELEASE in $(releases_ | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
# If the OS has an editions_() function, use it.
if [[ $(type -t editions_) == function ]]; then
for OPTION in $(editions_); do
echo "${OS} ${RELEASE} ${OPTION}"
done
elif [[ "${OS}" == "windows"* ]]; then
"languages_"
for OPTION in "${LANGS[@]}"; do
echo "${OS} ${RELEASE} ${OPTION}"
done
else
echo "${OS} ${RELEASE}"
fi
done
done
exit 0
}
list_isos() {
local URL
local FUNC
local OPTION
local OS
echo "OS|Release|Edition|URL"
for OS in $(os_support); do
. "${PUBLIC_DIR}/${OS}"
for RELEASE in $(releases_ | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
# If the OS has an editions_() function, use it.
if [[ $(type -t editions_) == function ]]; then
for OPTION in $(editions_); do
URL=$("$0" --url "${OS}" "${RELEASE}" "${OPTION}" 2>/dev/null | head -1)
if [ -z "${URL}" ]; then
echo "${OS}|${RELEASE}|${OPTION}|${URL}"
else
echo "${OS}|${RELEASE}|${OPTION}|${URL}"
fi
done
elif [[ "${OS}" == "windows"* ]]; then
languages_
for OPTION in "${LANGS[@]}"; do
#URL=$(./qget -u ${OS} ${RELEASE} ${OPTION})
echo "${OS}|${RELEASE}|${OPTION}|"
done
elif [[ "${OS}" == "macos" ]]; then
echo "${OS}|${RELEASE}|${OPTION}|"
else
URL=$("$0" --url "${OS}" "${RELEASE}" 2>/dev/null | head -1)
echo "${OS}|${RELEASE}|${OPTION}|${URL}"
fi
done
done
exit 0
}
function csv_data() {
local DISPLAY_NAME
local DL=""
local DOWNLOADER
local FUNC
local OPTION
local OS
local PNG
local RELEASE
local SVG
local HAS_ZSYNC=0
local OSNAME
local PRETTY
local ICON
local CATEGORY
local BASEDOF
local HOMEPAGE
local CREDENTIALS
local DESCRIPTION
# Check if zsync is available
if command -v zsync &>/dev/null; then
HAS_ZSYNC=1
fi
for OS in $(os_support); do
. "${PUBLIC_DIR}/${OS}"
local EDITIONS=""
DISPLAY_NAME="${PRETTY}"
SVG="" PNG=""
if [[ "${ICON}" == *.svg ]]; then
SVG="https://dh.osowoso.org/icons/${ICON}"
elif [[ "${ICON}" == *.png ]]; then
PNG="https://dh.osowoso.org/icons/${ICON}"
else
PNG="-"
fi
if [[ $(type -t editions_) == function ]]; then
EDITIONS=$(editions_)
fi
for RELEASE in $(releases_); do
if [[ "${OS}" == *"ubuntu"* ]] && [[ ${RELEASE} == *"daily"* ]] && [ ${HAS_ZSYNC} -eq 1 ]; then
DOWNLOADER="zsync"
else
DOWNLOADER="${DL}"
fi
# If the OS has an editions_() function, use it.
if [[ ${EDITIONS} ]]; then
for OPTION in ${EDITIONS}; do
echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
done
elif [[ "${OS}" == "windows"* ]]; then
languages_
for I18N in "${I18NS[@]}"; do
echo "${DISPLAY_NAME},${OS},${RELEASE},${I18N},${DOWNLOADER},${PNG},${SVG}"
done
else
echo "${DISPLAY_NAME},${OS},${RELEASE},,${DOWNLOADER},${PNG},${SVG}"
fi
done &
done
wait
}
function list_supported() {
list_csv | cut -d ',' -f2,3,4 | tr ',' ' '
exit 0
}
function list_by_category() {
local filter="${1,,}"
local OSNAME="" CATEGORY=""
for f in "${PUBLIC_DIR}"/*; do
[ -f "$f" ] || continue
OSNAME="" CATEGORY=""
eval "$(grep -E '^(OSNAME|CATEGORY)=' "$f" | head -2)"
[ -z "$OSNAME" ] && continue
echo "${CATEGORY,,}" | grep -qi "${filter}" && echo "$OSNAME"
done
exit 0
}
function test_result() {
local OS="${1}"
local RELEASE="${2}"
local EDITION="${3:-}"
local URL="${4:-}"
local RESULT="${5:-}"
if [ -n "${EDITION}" ]; then
OS="${OS}-${RELEASE}-${EDITION}"
else
OS="${OS}-${RELEASE}"
fi
if [ -n "${RESULT}" ]; then
# Pad the OS string for consistent output
OS=$(printf "%-35s" "${OS}")
echo -e "${RESULT}: ${OS} ${URL}"
else
OS=$(printf "%-36s" "${OS}:")
echo -e "${OS} ${URL}"
fi
}
function test_all() {
OS="${1}"
os_supported
local CHECK=""
local FUNC="${OS}"
if [[ "${OS}" == *ubuntu* && "${OS}" != "ubuntu-server" ]]; then
FUNC="ubuntu"
fi
local URL=""
. "${PUBLIC_DIR}/${OS}"
for RELEASE in $(releases_); do
. "${PUBLIC_DIR}/${OS}"
if [ "${OS}" == 'rebornos' ]; then
if curl -I "https://cdn.soulharsh007.dev/RebornOS-ISO/${ISO}"; then
test_result "${OS} ${RELEASE} ${URL} PASS"
else
test_result "${OS} ${RELEASE} ${URL} FAIL"
fi
elif [[ $(type -t editions_) == function ]]; then
. "${PUBLIC_DIR}/${OS}"
for EDITION in $(editions_); do
validate_release releases_
URL=$(get_ | cut -d' ' -f1 | head -n 1)
if [ "${OPERATION}" == "show" ]; then
test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}"
elif [ "${OPERATION}" == "test" ]; then
CHECK=$(web_check "${URL}" && echo "PASS" || echo "FAIL")
test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}" "${CHECK}"
fi
done
elif [[ "${OS}" == "windows"* ]]; then
. "${PUBLIC_DIR}/${OS}"
languages_
for I18N in "${I18NS[@]}"; do
validate_release releases_
if [ "${OPERATION}" == "show" ]; then
test_result "${OS}" "${RELEASE}" "${I18N}" ""
elif [ "${OPERATION}" == "test" ]; then
test_result "${OS}" "${RELEASE}" "${I18N}" "${URL}" "SKIP"
fi
done
elif [[ "${OS}" == "macos" ]]; then
validate_release releases_
(get_)
elif [ "${OS}" == "ubuntu-server" ]; then
validate_release releases_
(get_)
elif [[ "${OS}" == *ubuntu* ]]; then
validate_release releases_
(get_)
else
validate_release releases_
URL=$(get_ | cut -d' ' -f1 | head -n 1)
if [ "${OPERATION}" == "show" ]; then
test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}"
elif [ "${OPERATION}" == "test" ]; then
CHECK=$(web_check "${URL}" && echo "PASS" || echo "FAIL")
test_result "${OS}" "${RELEASE}" "${EDITION}" "${URL}" "${CHECK}"
fi
fi
done
}
# Verify a detached GPG signature against a file.
# KEY_SOURCE: fingerprint → fetched from keyserver; https://... → downloaded.
function check_signature() {
local iso="$1"
local sig="$2"
local key_id="${3:-${GPG:-}}"
if ! command -v gpg &>/dev/null; then
echo $"WARNING! gpg not found — skipping signature check"
return 1
fi
echo -n $"Checking GPG signature for ${iso}... "
local GPG_HOME
GPG_HOME=$(mktemp -d)
chmod 700 "${GPG_HOME}"
local import_ok=0
if [[ "${key_id}" =~ ^https?:// ]]; then
local kf
kf=$(mktemp)
curl --disable --silent --location -o "${kf}" "${key_id}" 2>/dev/null \
&& GNUPGHOME="${GPG_HOME}" gpg --quiet --import "${kf}" 2>/dev/null \
&& import_ok=1
rm -f "${kf}"
elif [ -n "${key_id}" ]; then
GNUPGHOME="${GPG_HOME}" gpg --quiet \
--keyserver hkps://keys.openpgp.org --recv-keys "${key_id}" 2>/dev/null \
|| GNUPGHOME="${GPG_HOME}" gpg --quiet \
--keyserver hkps://keyserver.ubuntu.com --recv-keys "${key_id}" 2>/dev/null
import_ok=1
fi
if [ "${import_ok}" -eq 0 ]; then
echo $"ERROR! Failed to import GPG key: ${key_id}"
rm -rf "${GPG_HOME}"
exit 1
fi
if GNUPGHOME="${GPG_HOME}" gpg --verify "${sig}" "${iso}" 2>/dev/null; then
echo $"Good!"
else
echo $"ERROR!"
echo $"Signature verification failed for ${iso}"
rm -rf "${GPG_HOME}"
exit 1
fi
rm -rf "${GPG_HOME}"
}
function open_homepage() {
. "${PUBLIC_DIR}/${1}"
local XDG_OPEN=""
if [ -z "${PRETTY}" ]; then
error_specify_os
else
# shellcheck disable=SC2034
XDG_OPEN=$(xdg-open "${HOMEPAGE}" || sensible-browser "${HOMEPAGE}" || x-www-browser "${HOMEPAGE}" || gnome-open "${HOMEPAGE}")
exit 0
fi
}
function check_vm_folder_name() {
local name="${1}"
if [[ "$name" =~ [^a-zA-Z0-9._+\-] ]]; then
echo $"ERROR! VM folder name '${name}' contains invalid characters." >&2
exit 1
fi
if [ -d "$name" ]; then
echo $"WARNING! VM folder '${name}' already exists, files may be overwritten." >&2
fi
local avail_kb
avail_kb=$(df -k . 2>/dev/null | awk 'NR==2{print $4}')
if [[ -n "$avail_kb" && "$avail_kb" -lt 5242880 ]]; then
echo $"WARNING! Less than 5 GB of free disk space available." >&2
fi
}
function check_download_url() {
local url="${1}"
local result http_code content_type
result=$(curl --silent --head --location --max-time 15 --connect-timeout 5 \
--write-out "%{http_code} %{content_type}" --output /dev/null "${url}" 2>/dev/null)
http_code="${result%% *}"
content_type="${result#* }"
if [[ "$http_code" != "200" ]]; then
echo $"WARNING: URL returned HTTP ${http_code}" >&2
return 1
fi
if echo "$content_type" | grep -qi "text/html"; then
echo $"WARNING: URL points to an HTML page, not a file" >&2
return 1
fi
return 0
}
function create_vm() {
# shellcheck disable=SC2206
local URL_HASH=(${1// / })
local URL="${URL_HASH[0]}"
local HASH="${URL_HASH[1]}"
local ISO="${URL##*/}"
# Offer magnet download if available and aria2c present
if [ -n "${MAGNET:-}" ] && command -v aria2c &>/dev/null; then
echo "Magnet link available. Use aria2c? [y/N]"
read -r -n 1 ans
echo
if [[ "${ans,,}" == "y" ]]; then
torrent_get "${MAGNET}" "${VM_PATH}" && make_vm_config "${ISO}"
return
fi
fi
check_download_url "${URL}" || true
web_get "${URL}" "${VM_PATH}"
if [ -n "${HASH}" ]; then
check_hash "${ISO}" "${HASH}"
fi
# shellcheck disable=SC2076
. "${PUBLIC_DIR}/${OS}"
#"extract_" 2>/dev/null
declare -f extract_ > /dev/null && extract_
make_vm_config "${ISO}"
table_write ./TODO/all
}
function create_config() {
local VM_PATH="${1}"
local INPUT="${2}"
local FIXED_ISO=""
OS="custom"
if ! mkdir "${VM_PATH}" 2>/dev/null; then
echo $"WARNING! This will overwrite content of directory: ${VM_PATH}"
fi
if [[ "${INPUT}" == "http://"* ]] || [[ "${INPUT}" == "https://"* ]]; then
INPUT="$(web_redirect "${INPUT}")"
if [[ "${INPUT}" == *".iso" ]] || [[ "${INPUT}" == *".img" ]]; then
web_get "${INPUT}" "${VM_PATH}"
INPUT="${INPUT##*/}"
else
error_not_supported_image
fi
fi
function moving_image() {
echo $"Moving image to VM dir"
}
if [ ! -f "${INPUT}" ]; then
echo $"ERROR! The input must be a valid URL or path to an ISO, IMG, or QCOW2 file."
exit 1
elif [[ "${INPUT}" == *".iso" ]]; then
moving_image && mv "${INPUT}" "${VM_PATH}"
CUSTOM_IMAGE_TYPE="iso"
elif [[ "${INPUT}" == *".img" ]]; then
moving_image && mv "${INPUT}" "${VM_PATH}"
CUSTOM_IMAGE_TYPE="img"
elif [[ "${INPUT}" == *".qcow2" ]]; then
moving_image && mv "${INPUT}" "${VM_PATH}/disk.qcow2"
CUSTOM_IMAGE_TYPE="qcow2"
else
error_not_supported_image
fi
INPUT="$(basename "${INPUT}")"
echo $"Creating custom VM config for ${INPUT##*/}."
case "${INPUT,,}" in
*freebsd*) CUSTOM_OS="freebsd";;
*kolibrios*) CUSTOM_OS="kolibrios";;
*reactos*) CUSTOM_OS="reactos";;
*windows-server*|*eval_oemret_x*|*eval_x*) CUSTOM_OS="windows-server";;
*windows*|win*)
CUSTOM_OS="windows"
# Older windows 10 ISOs use the year followed by the month rather than the year & half). Match any text for language.
if [ "${3}" != "--disable-unattended" ] && ( [ "${3}" == "--unattended" ] || grep -E -q 'Win(10|11)_([0-9]{2}H(1|2)|[0-9]{4})_[^.]*?(x64|x32)(v[0-9])?.iso' <<< "${INPUT}" ); then
echo $"Creating unattended Windows installation files. To disable, pass --disable-unattended"
echo
echo $"Downloading VirtIO drivers..."
web_get "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso" "${VM_PATH}"
FIXED_ISO="virtio-win.iso"
rm -f "${VM_PATH}/unattended.iso"
unattended_windows "${VM_PATH}"
fi
;;
*) CUSTOM_OS="linux";;
esac
echo -e $"Selecting OS: ${CUSTOM_OS}. If this is incorrect, please modify the config file to include the correct OS.\n"
make_vm_config "${INPUT}" "${FIXED_ISO}"
}
# Use command -v command to check if quickemu is in the system's PATH and
# fallback to checking if quickemu is in the current directory.
function find_latest_qemu_version() {
local latest
latest=$(floatversion --full -M \
"$(curl --disable -sLf --retry 3 --max-time 8 \
"https://github.com/qemu/qemu/tags" | grep -s 'Link--primary')" 2>/dev/null)
if [ -n "$latest" ]; then
echo $"Latest QEMU release: ${latest}"
else
echo $"Could not fetch QEMU version (no network or floatversion missing)" >&2
fi
}
function resolve_quickemu() {
command -v quickemu || \
if [ -x "./quickemu" ]; then
echo "$(pwd)/quickemu"
else
echo $"quickemu not found" >&2
exit 1
fi
}
run_itself() {
if [ -n "${1}" ]; then
OS="${1,,}"
else
error_specify_os
fi
os_supported
. "${PUBLIC_DIR}/${OS}"
if [ -n "${2}" ]; then
RELEASE="${2}"
VM_PATH="${OS}-${RELEASE}"
check_vm_folder_name "${VM_PATH}"
# If the OS has an editions_() function, use it.
if [[ $(type -t editions_) == function ]]; then
validate_release releases_
EDITIONS=$(editions_)
if [ -n "${3}" ]; then
EDITION="${3}"
if [[ ! "${EDITIONS[*]}" = *"${EDITION}"* ]]; then
echo -e $"ERROR! ${EDITION} is not a supported ${PRETTY} edition\n"
echo -n $' - Supported editions: '
for EDITION in "${EDITIONS[@]}"; do
echo -n "${EDITION} "
done
echo ""
exit 1
fi
else
show_os_info "${OS}"
echo -e $"\nERROR! You must specify an edition."
exit 1
fi
handle_missing
VM_PATH="${OS}-${RELEASE}-${EDITION}"
create_vm "$("get_" "${EDITION}")"
elif [ "${OS}" == "macos" ]; then
# macOS doesn't use create_vm()
validate_release releases_
get_
elif [[ "${OS}" == *"ubuntu-server"* ]]; then
# (Comes before regular Ubuntu, or the code tries to download the desktop) #
# Ubuntu doesn't use create_vm()
validate_release releases_
get_
elif [[ "${OS}" == *"ubuntu"* ]]; then
# Ubuntu doesn't use create_vm()
validate_release releases_
get_
elif [[ "${OS}" == "windows"* ]]; then
I18N="English International"
languages_"${OS}"
if [ -n "${3}" ]; then
I18N="${3}"
if [[ ! "${I18NS[*]}" = *"${I18N}"* ]]; then
error_not_supported_lang
fi
VM_PATH="$(echo "${OS}-${RELEASE}-${I18N// /-}" | tr -d '()')"
fi
validate_release releases_
get_
else
validate_release releases_
create_vm "$("get_")"
fi
else
error_specify_release
fi
}
# shellcheck disable=SC2046
function run_ui() {
if ! command -v gum &> /dev/null; then
echo $"gum could not be found, please install it first"
exit 1
fi
OS=$(gum filter --height=17 --header="Select an OS:" $(os_support))
#os_info "${OS}" > "$TMPFILE"
. "${PUBLIC_DIR}/${OS}"
RELEASE=$(gum filter --height=9 --header="Select $OS release:" ${RELEASES})
if [ -n "${EDITIONS}" ]; then
EDITION=$(gum filter --height=9 --header="Select $OS $RELEASE edition:" ${EDITIONS})
echo ''
run_itself "${OS}" "${RELEASE}" "${EDITION}"
else
echo ''
run_itself "${OS}" "${RELEASE}"
fi
}
function help_message() {
#shellcheck disable=SC2016
printf '
_
__ _ __ _ ____| |_
/ _` |/ _` |/ _ \ _|
| (_| | (_| | __/| |_
\__, |\__, |\___|\___|
|_||___/ v%s using curl %s
--------------------------------------------------------------------------------
Project - https://github.com/osowoso/distrohopper
Discord - https://discord.gg/UQRE3aNF
--------------------------------------------------------------------------------
Usage:
qget <os> <release> [edition]
qget ubuntu 22.04
Advanced usage:
qget <arg> [path] <os> [release] [edition]
qget --download ubuntu 22.04
Arguments:
--arch <arch> : Set architecture (default: x86_64)
--download <os> <release> [edition] : Download image; no VM configuration
--create-config <os> [path/url] [flags] : Create VM config for an OS image
--open-homepage <os> : Open homepage for the OS
--show [os] : Show OS information
--version : Show version
--help : Show this help message
--ui : Run in UI mode
------------------------------------ Flags -------------------------------------
--create-config:
--disable-unattended : Force qget not to set up an unattended installation
-------------------------- For testing & development ---------------------------
--url [os] [release] [edition] : Show image URL(s)
--check [os] [release] [edition] : Check image URL(s)
--list : List all supported systems
--list-csv : List everything in csv format
--list-json : List everything in json format
--list-category <tag> : List distros matching a category (e.g. Gaming, Security)
--------------------------------------------------------------------------------
Supported Operating Systems:\n\n' "$qgetVersion" "${CURL_VERSION}"
os_support | fmt -w 80
}
trap cleanup EXIT
if ((BASH_VERSINFO[0] < 4)); then
echo $"Sorry, you need bash 4.0 or newer to run this script."
exit 1
fi
QUICKEMU=$(resolve_quickemu)
I18NS=()
OPERATION=""
ARCH="amd64"
CURL=$(command -v curl)
if [ ! -x "${CURL}" ]; then
echo $"ERROR! curl not found. Please install curl"
exit 1
fi
CURL_VERSION=$("${CURL}" --version | head -n 1 | cut -d' ' -f2)
# Note: Old commands `list`, `list_csv`, `list_json` are kept for backwards compatibility
# They now map to the new `--list`, `--list-csv`, `--list-json` options
case "${1}" in
--ui)
OPERATION="ui"
shift
run_ui
;;
--download|-download)
OPERATION="download"
shift
;;
--create-config|-create-config)
OPERATION="config"
shift
create_config "${@}"
;;
--open-homepage|-open-homepage)
shift
open_homepage "${1}"
;;
--show|-show)
shift
if [ -z "${1}" ]; then
for OS in $(os_support); do
show_os_info "${OS}"
done
else
show_os_info "${1}"
fi
exit 0
;;
--version|-version)
WHERE=$(dirname "${BASH_SOURCE[0]}")
"${WHERE}/quickemu" --version
exit 0
;;
--help|-help|--h|-h)
help_message
exit 0
;;
--url|-url)
OPERATION="show"
shift
if [ -z "${1}" ]; then
for OS in $(os_support); do
(test_all "${OS}")
done
exit 0
elif [ -z "${2}" ]; then
test_all "${1}"
exit 0
fi
;;
--check|-check)
OPERATION="test"
shift
if [ -z "${1}" ]; then
for OS in $(os_support); do
(test_all "${OS}")
done
exit 0
elif [ -z "${2}" ]; then
test_all "${1}"
exit 0
fi
;;
--list-os|-list-os)
os_support
exit 0
;;
--list-csv|-list-csv|list|list_csv)
list_csv
;;
--list-json|-list-json|list_json)
list_json
;;
--list|-list)
list_supported
;;
--list-category|-list-category)
shift
[ -z "${1}" ] && { echo $"ERROR! Specify a category filter (e.g. Gaming, Security, Server)." >&2; exit 1; }
list_by_category "${1}"
;;
--qemu-version|-qemu-version) find_latest_qemu_version
exit 0
;;
-a|--arch)
ARCH="${2}"
shift 2
;;
-*)
error_not_supported_argument
;;
esac
run_itself "$@"
# vim:tabstop=4:shiftwidth=4:noexpandtab
Reference in a new issue View git blame Copy permalink