1811 lines
58 KiB
Bash
Executable File
1811 lines
58 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Install JRiver Media Center and associated services
|
|
# See installJRMC --help or print_help() below for usage
|
|
#
|
|
# Copyright (c) 2021-2024 Bryan C. Roessler
|
|
# This software is released under the Apache License.
|
|
# https://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# TODO (v2)
|
|
# 1. Interactive mode
|
|
# 2. Additional containerization (createrepo and rpmbuild)
|
|
# 3. Tests
|
|
#
|
|
# BUGS
|
|
# 1. No createrepo on Mint
|
|
|
|
shopt -s extglob
|
|
|
|
declare -g SCRIPT_VERSION="1.3.0-dev"
|
|
declare -g BOARD_URL="https://yabb.jriver.com/interact/index.php/board,86.0.html" # MC33
|
|
declare -g MC_VERSION="33.0.15" # Do find all replace
|
|
declare -g MC_DEFAULT_REPO="bullseye" # should match the MC_VERSION
|
|
declare -ig SELF_UPDATE=1
|
|
|
|
print_help() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
cat <<-EOF
|
|
USAGE:
|
|
installJRMC [[OPTION] [VALUE]]...
|
|
|
|
If no options (excluding -d or --debug) are provided installJRMC defaults to '--install repo'.
|
|
|
|
OPTIONS
|
|
--install, -i repo|local
|
|
repo: Install MC from repository, updates are handled by the system package manager
|
|
local: Build and install MC package locally from official source release
|
|
--build[=suse|fedora|centos]
|
|
Build RPM from source DEB but do not install
|
|
Optionally, specify a target distro for cross-building (ex. --build=suse, note the '=')
|
|
--compat
|
|
Build/install MC locally without minimum dependency version requirements
|
|
--mcversion VERSION
|
|
Specify the MC version, ex. "$MC_VERSION" (default: latest version)
|
|
--arch VERSION
|
|
Specify the MC architecture, ex. "amd64", "arm64", etc (default: host architecture)
|
|
--mcrepo REPO
|
|
Specify the MC repository, ex. "bullseye", "bookworm", "noble", etc (default: latest official)
|
|
--outputdir PATH
|
|
Generate rpmbuild output in this directory (default: ./output)
|
|
--restorefile MJR_RESTORE_FILE
|
|
Restore file location for automatic license registration
|
|
--betapass PASSWORD
|
|
Enter beta team password for access to beta builds
|
|
--service, -s SERVICE
|
|
See SERVICES section below for a list of possible services to install
|
|
--service-type user|system
|
|
Starts services at boot (system) or at user login (user) (default: per service, see SERVICES)
|
|
--container, -c CONTAINER (TODO: Under construction)
|
|
See CONTAINERS section below for a list of possible services to install
|
|
--createrepo[=suse|fedora|centos]
|
|
Build rpm, copy to webroot, and run createrepo.
|
|
Use in conjunction with --build=TARGET for crossbuilding repos
|
|
Optionally, specify a target distro for non-native repo (ex. --createrepo=fedora, note the '=')
|
|
--createrepo-webroot PATH
|
|
Specify the webroot directory to install the repo (default: /var/www/jriver)
|
|
--createrepo-user USER
|
|
Specify the web server user if it differs from \$USER
|
|
--uninstall, -u
|
|
Uninstall JRiver MC, remove services, containers, and firewall rules (does not remove library files)
|
|
--yes, -y, --auto
|
|
Always assume yes for questions
|
|
--version, -v
|
|
Print this script version and exit
|
|
--debug, -d
|
|
Print debug output
|
|
--help, -h
|
|
Print help dialog and exit
|
|
|
|
SERVICES
|
|
jriver-mediaserver (default --service-type=user)
|
|
Enable and start a mediaserver systemd service (requires an existing X server)
|
|
jriver-mediacenter (user)
|
|
Enable and start a mediacenter systemd service (requires an existing X server)
|
|
jriver-x11vnc (user)
|
|
Enable and start x11vnc for the local desktop (requires an existing X server)
|
|
Usually combined with jriver-mediaserver or jriver-mediacenter services
|
|
--vncpass and --display are optional (see below)
|
|
jriver-xvnc (system)
|
|
Enable and start a new Xvnc session running JRiver Media Center
|
|
--vncpass PASSWORD
|
|
Set the vnc password for x11vnc/Xvnc access. If no password is set, installJRMC
|
|
will either use existing password stored in \$HOME/.vnc/jrmc_passwd or use no password
|
|
--display DISPLAY
|
|
Display to use for x11vnc/Xvnc (default: The current display (x11vnc) or the
|
|
current display incremented by 1 (Xvnc))
|
|
jriver-createrepo (system)
|
|
Install hourly service to build latest MC RPM and run createrepo
|
|
|
|
CONTAINERS (TODO: Under construction)
|
|
mediacenter-xvnc
|
|
createrepo
|
|
EOF
|
|
}
|
|
|
|
#######################################
|
|
# Helpers
|
|
#######################################
|
|
debug() { (( DEBUG )) && echo "Debug: $*"; }
|
|
err() { echo "Error: $*" >&2; }
|
|
ask_ok() {
|
|
declare response
|
|
(( YES_SWITCH )) && return 0
|
|
read -r -p "$* [y/N]: " response
|
|
[[ ${response,,} =~ ^(yes|y)$ ]]
|
|
}
|
|
execute() {
|
|
if debug "$*"; then
|
|
"$@"
|
|
else
|
|
"$@" &>/dev/null
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Perform OS detection and fallback
|
|
# Generate OS-specific functions
|
|
#######################################
|
|
init() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
declare -g ID RPM_MGR ARCH
|
|
declare -ga PKG_INSTALL PKG_REMOVE PKG_UPDATE PKG_QUERY
|
|
|
|
echo "Starting installJRMC"
|
|
(( DEBUG )) || echo "To enable debugging output, use --debug or -d"
|
|
(( EUID == 0 )) && err "Running as root user"
|
|
|
|
if [[ -f /etc/os-release ]]; then
|
|
source "/etc/os-release"
|
|
else
|
|
err "/etc/os-release not found"
|
|
err "Your OS is unsupported"
|
|
print_help
|
|
exit 1
|
|
fi
|
|
|
|
# Detect architecture and translate to MC convention
|
|
ARCH=$(uname -m)
|
|
case $ARCH in
|
|
x86_64) ARCH="amd64" ;;
|
|
aarch64) ARCH="arm64" ;;
|
|
esac
|
|
|
|
debug "Detected host platform: $ID $VERSION_ID $ARCH"
|
|
|
|
# Normalize ID and set distro-specific vars
|
|
case $ID in
|
|
debian|arch) ;;
|
|
centos|fedora)
|
|
RPM_MGR=$(command -v dnf &>/dev/null && echo "dnf" || echo "yum")
|
|
;;
|
|
rhel|almalinux) ID="centos" ;;
|
|
linuxmint|neon|zorin|*ubuntu*) ID="ubuntu" ;;
|
|
*suse*) ID="suse" ;;
|
|
raspbian) ID="debian" ;;
|
|
*)
|
|
err "Auto-detecting distro, this is unreliable and --compat may be required"
|
|
if command -v dnf &>/dev/null; then
|
|
ID="fedora"
|
|
RPM_MGR="dnf"
|
|
elif command -v yum &>/dev/null; then
|
|
ID="centos"
|
|
RPM_MGR="yum"
|
|
COMPAT_SWITCH=1
|
|
elif command -v apt-get &>/dev/null; then
|
|
ID="ubuntu"
|
|
elif command -v pacman &>/dev/null; then
|
|
ID="arch"
|
|
else
|
|
err "OS detection failed!"
|
|
ask_ok "Continue with manual installation?" || exit 1
|
|
ID="unknown"
|
|
REPO_INSTALL_SWITCH=0
|
|
BUILD_SWITCH=1
|
|
LOCAL_INSTALL_SWITCH=1
|
|
fi
|
|
esac
|
|
|
|
# Match the MC repo to the system
|
|
if [[ $ID == debian || $ID == ubuntu ]]; then
|
|
echo "Ubuntu codename: $UBUNTU_CODENAME"
|
|
echo "Version codename: $VERSION_CODENAME"
|
|
MC_DEFAULT_REPO=${UBUNTU_CODENAME:-${VERSION_CODENAME:-$MC_DEFAULT_REPO}}
|
|
fi
|
|
|
|
# Change the repo for user-specified legacy versions
|
|
if [[ -n $USER_MC_VERSION ]]; then
|
|
case $MC_MVERSION in
|
|
2[0-6]) MC_DEFAULT_REPO="jessie" ;;
|
|
2[7-9]|30) MC_DEFAULT_REPO="buster" ;;
|
|
31) MC_DEFAULT_REPO="bullseye" ;;
|
|
# After this point, things get messy with multiple repos for the same version
|
|
esac
|
|
fi
|
|
|
|
debug "Using host platform: $ID $VERSION_ID"
|
|
debug "Using MC repository: ${MC_REPO:-$MC_DEFAULT_REPO}"
|
|
|
|
# Set distro-specific package manager commands
|
|
case $ID in
|
|
fedora|centos)
|
|
PKG_INSTALL=(execute sudo "$RPM_MGR" install -y)
|
|
PKG_REMOVE=(execute sudo "$RPM_MGR" remove -y)
|
|
PKG_UPDATE=(execute sudo "$RPM_MGR" makecache)
|
|
PKG_QUERY=(rpm -q)
|
|
PKG_INSTALL_LOCAL() { install_mc_rpm; }
|
|
;;
|
|
debian|ubuntu)
|
|
PKG_INSTALL=(execute sudo apt-get -f install -y -q0)
|
|
PKG_REMOVE=(execute sudo apt-get remove --auto-remove -y -q0)
|
|
PKG_UPDATE=(execute sudo apt-get update -y -q0)
|
|
PKG_QUERY=(dpkg -s)
|
|
PKG_INSTALL_LOCAL() { install_mc_deb; }
|
|
;;
|
|
suse)
|
|
PKG_INSTALL=(execute sudo zypper --gpg-auto-import-keys --non-interactive --quiet install --force --no-confirm)
|
|
PKG_REMOVE=(execute sudo zypper --non-interactive --quiet remove --clean-deps)
|
|
PKG_UPDATE=(execute sudo zypper --non-interactive --quiet refresh jriver)
|
|
PKG_QUERY=(rpm -q)
|
|
PKG_INSTALL_LOCAL() { install_mc_rpm; }
|
|
;;
|
|
arch)
|
|
PKG_INSTALL=(execute sudo pacman -Sy --noconfirm)
|
|
PKG_REMOVE=(execute sudo pacman -Rs --noconfirm)
|
|
PKG_UPDATE=(execute sudo pacman -Syy)
|
|
PKG_QUERY=(sudo pacman -Qs)
|
|
PKG_INSTALL_LOCAL() { install_mc_arch; }
|
|
;;
|
|
unknown)
|
|
PKG_INSTALL=(:)
|
|
PKG_REMOVE=(:)
|
|
PKG_UPDATE=(:)
|
|
PKG_QUERY=(:)
|
|
PKG_INSTALL_LOCAL() { install_mc_generic; }
|
|
esac
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Parses user input and sets sensible defaults
|
|
#######################################
|
|
parse_input() {
|
|
debug "Running: ${FUNCNAME[0]} $*"
|
|
|
|
declare -g BUILD_SWITCH REPO_INSTALL_SWITCH LOCAL_INSTALL_SWITCH \
|
|
COMPAT_SWITCH TEST_SWITCH CREATEREPO_SWITCH UNINSTALL_SWITCH \
|
|
YES_SWITCH USER_MC_VERSION MJR_RESTORE_FILE BETAPASS SERVICE_TYPE \
|
|
VNCPASS USER_DISPLAY MC_REPO
|
|
declare -ga SERVICES CONTAINERS
|
|
local long_opts short_opts input
|
|
|
|
# Defaults
|
|
declare -g \
|
|
BUILD_TARGET="$ID" \
|
|
REPO_TARGET="$ID" \
|
|
CREATEREPO_USER="$USER" \
|
|
OUTPUT_DIR="$SCRIPT_DIR/output" \
|
|
CREATEREPO_WEBROOT="/var/www/jriver" \
|
|
USER="${SUDO_USER:-$USER}"
|
|
|
|
declare -g SCRIPT_PATH; SCRIPT_PATH=$(readlink -f "${BASH_SOURCE[0]}")
|
|
declare -g SCRIPT_DIR=; SCRIPT_DIR=$(readlink -f "$(dirname "${BASH_SOURCE[0]}")")
|
|
declare -g HOME; HOME=$(getent passwd "$USER" | cut -d: -f6)
|
|
|
|
# Set some defaults if zero or one arguments are passed
|
|
if [[ $# -eq 0 && $ID != "unknown" ]]; then
|
|
debug "Automatically setting --install repo"
|
|
REPO_INSTALL_SWITCH=1
|
|
elif [[ $# -eq 1 || $# -eq 2 ]]; then
|
|
case "$1" in
|
|
--debug | -d | -y | --yes | --auto | --mcrepo | --mcversion | \
|
|
--arch | --betapass | --restorefile | --outputdir | --no-self-update)
|
|
if [[ $ID != "unknown" ]]; then
|
|
debug "Automatically setting --install repo"
|
|
REPO_INSTALL_SWITCH=1
|
|
fi
|
|
;;
|
|
--compat)
|
|
if [[ $# -eq 1 ]]; then
|
|
BUILD_SWITCH=1
|
|
LOCAL_INSTALL_SWITCH=1
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
long_opts="install:,build::,outputdir:,mcversion:,arch:,mcrepo:,compat,"
|
|
long_opts+="restorefile:,betapass:,"
|
|
long_opts+="service-type:,service:,services:,"
|
|
long_opts+="version,debug,verbose,help,uninstall,tests,yes,auto,no-self-update,"
|
|
long_opts+="createrepo::,createrepo-webroot:,createrepo-user:,"
|
|
long_opts+="vncpass:,display:,container:"
|
|
short_opts="+i:vb::dhus:c:"
|
|
|
|
# Reset DEBUG and catch with getopt
|
|
declare -g DEBUG=0
|
|
|
|
if input=$(getopt -o $short_opts -l $long_opts -- "$@"); then
|
|
eval set -- "$input"
|
|
while true; do
|
|
case $1 in
|
|
--install|-i)
|
|
shift
|
|
case $1 in
|
|
local|rpm)
|
|
BUILD_SWITCH=1
|
|
LOCAL_INSTALL_SWITCH=1
|
|
;;
|
|
repo|remote)
|
|
REPO_INSTALL_SWITCH=1
|
|
;;
|
|
esac
|
|
;;
|
|
--build|-b)
|
|
BUILD_SWITCH=1
|
|
shift && BUILD_TARGET="$1"
|
|
;;
|
|
--outputdir)
|
|
shift && OUTPUT_DIR="$1"
|
|
;;
|
|
--mcversion)
|
|
shift
|
|
if [[ $1 =~ ([0-9]+.[0-9]+.[0-9]+) ]]; then
|
|
USER_MC_VERSION="$1"
|
|
else
|
|
err "Bad --mcversion"
|
|
print_help
|
|
exit 1
|
|
fi
|
|
;;
|
|
--arch)
|
|
shift
|
|
echo "Switching from $ARCH to $1 architecture"
|
|
ARCH="$1"
|
|
;;
|
|
--mcrepo)
|
|
shift && MC_REPO="$1"
|
|
;;
|
|
--restorefile)
|
|
shift && MJR_RESTORE_FILE="$1"
|
|
;;
|
|
--betapass)
|
|
shift && BETAPASS="$1"
|
|
;;
|
|
--service-type)
|
|
shift && SERVICE_TYPE="$1"
|
|
;;
|
|
--service|-s|--services)
|
|
shift && SERVICES+=("$1")
|
|
;;
|
|
--createrepo)
|
|
BUILD_SWITCH=1
|
|
CREATEREPO_SWITCH=1
|
|
shift && REPO_TARGET="$1" && BUILD_TARGET="$1"
|
|
;;
|
|
--createrepo-webroot)
|
|
shift && CREATEREPO_WEBROOT="$1"
|
|
;;
|
|
--createrepo-user)
|
|
shift && CREATEREPO_USER="$1"
|
|
;;
|
|
--vncpass)
|
|
shift && VNCPASS="$1"
|
|
;;
|
|
--display)
|
|
shift && USER_DISPLAY="$1"
|
|
;;
|
|
--compat)
|
|
COMPAT_SWITCH=1
|
|
BUILD_SWITCH=1
|
|
;;
|
|
--no-self-update)
|
|
SELF_UPDATE=0
|
|
;;
|
|
--container|-c)
|
|
shift && CONTAINERS+=("$1")
|
|
;;
|
|
--yes|-y|--auto)
|
|
YES_SWITCH=1
|
|
;;
|
|
--version|-v)
|
|
echo "Version: $SCRIPT_VERSION"
|
|
exit 0
|
|
;;
|
|
--debug|-d|--verbose)
|
|
DEBUG=1
|
|
;;
|
|
--help|-h)
|
|
print_help
|
|
exit
|
|
;;
|
|
--uninstall|-u)
|
|
UNINSTALL_SWITCH=1
|
|
;;
|
|
--tests)
|
|
TEST_SWITCH=1
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
else
|
|
err "Incorrect options provided"
|
|
print_help && exit 1
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Uses several methods to determine the latest JRiver MC version
|
|
#######################################
|
|
set_mc_version() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
declare -g MC_VERSION_SOURCE MC_MVERSION MC_ROOT
|
|
declare -g MC_PKG MC_RPM
|
|
local cnt
|
|
|
|
# Determine the latest MC version
|
|
# User input
|
|
if [[ -n $USER_MC_VERSION ]]; then
|
|
MC_VERSION_SOURCE="user input"
|
|
MC_VERSION="$USER_MC_VERSION"
|
|
# Containerized package manager
|
|
elif install_package --silent buildah \
|
|
&& cnt=$(buildah from --quiet alpine:edge 2>/dev/null) \
|
|
&& buildah run "$cnt" -- sh -c \
|
|
"apk add apt" &>/dev/null \
|
|
&& buildah run "$cnt" -- sh -c \
|
|
"echo 'deb [trusted=no arch=amd64,i386,armhf,arm64] http://dist.jriver.com/latest/mediacenter/ ${MC_REPO:-$MC_DEFAULT_REPO} main' > /etc/apt/sources.list 2>&1" &>/dev/null \
|
|
&& buildah run "$cnt" -- sh -c \
|
|
"apt update --allow-insecure-repositories &>/dev/null" &>/dev/null \
|
|
&& MC_VERSION=$(buildah run "$cnt" -- apt-cache policy mediacenter?? | grep Candidate | awk '{print $2}' | sort -V | tail -n1) &>/dev/null \
|
|
&& [[ $MC_VERSION =~ ([0-9]+.[0-9]+.[0-9]+) ]]; then
|
|
MC_VERSION_SOURCE="containerized package manager"
|
|
execute buildah rm "$cnt"
|
|
# Webscrape
|
|
elif install_package --silent wget \
|
|
&& MC_VERSION=$(wget -qO- "$BOARD_URL" | grep -o "[0-9][0-9]\.[0-9]\.[0-9]\+" | head -n 1) \
|
|
&& [[ $MC_VERSION =~ ([0-9]+.[0-9]+.[0-9]+) ]]; then
|
|
MC_VERSION_SOURCE="webscrape"
|
|
# Hardcoded
|
|
else
|
|
MC_VERSION_SOURCE="hardcoded"
|
|
err "Warning! Using hardcoded version number"
|
|
fi
|
|
|
|
# Set major version number and other variables
|
|
MC_MVERSION="${MC_VERSION%%.*}"
|
|
MC_PKG="mediacenter$MC_MVERSION"
|
|
MC_RPM="$OUTPUT_DIR/RPMS/x86_64/mediacenter$MC_MVERSION-$MC_VERSION.x86_64.rpm"
|
|
MC_ROOT="/usr/lib/jriver/Media Center $MC_MVERSION"
|
|
|
|
if [[ $MC_VERSION_SOURCE == "user input" ]]; then
|
|
# Append explicit package version when user provides --mcversion
|
|
case $ID in
|
|
fedora|centos|suse)
|
|
MC_PKG+="-$MC_VERSION"
|
|
;;
|
|
debian|ubuntu)
|
|
MC_PKG+="=$MC_VERSION"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
echo "Using MC version $MC_VERSION from the ${MC_REPO:-$MC_DEFAULT_REPO} repo (determined by $MC_VERSION_SOURCE)"
|
|
return 0
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs a package using the system package manager
|
|
# Arguments:
|
|
# One or more package names
|
|
# Options:
|
|
# --no-install-check: Do not check if package is already installed
|
|
# --no-gpg-check: Disable GPG checks for RPM based distros
|
|
# --allow-downgrades: Useful for installing specific MC versions
|
|
# --silent, -s: Do not print errors (useful for optional packages)
|
|
#######################################
|
|
install_package() {
|
|
debug "Running: ${FUNCNAME[0]}" "$@"
|
|
|
|
local -a pkg_array install_flags
|
|
local -A pkg_aliases
|
|
local input pkg
|
|
local no_install_check=0 allow_downgrades=0 silent=0 refresh=0 no_gpg_check=0
|
|
local long_opts="no-install-check,allow-downgrades,no-gpg-check,refresh,silent"
|
|
|
|
input=$(getopt -o +s -l "$long_opts" -- "$@") || { err "Incorrect options provided"; exit 1; }
|
|
eval set -- "$input"
|
|
|
|
while true; do
|
|
case $1 in
|
|
--no-install-check) no_install_check=1 ;;
|
|
--allow-downgrades) allow_downgrades=1 ;;
|
|
--no-gpg-check) no_gpg_check=1 ;;
|
|
--refresh) refresh=1 ;;
|
|
--silent|-s) silent=1 ;;
|
|
--) shift; break ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# Define package aliases based on the distribution
|
|
case $ID in
|
|
debian|ubuntu)
|
|
pkg_aliases=(
|
|
["rpm-build"]="rpm"
|
|
["createrepo_c"]="createrepo"
|
|
["tigervnc-server"]="tigervnc-standalone-server"
|
|
)
|
|
;;
|
|
esac
|
|
|
|
# Filter out already installed packages
|
|
for pkg in "$@"; do
|
|
if [[ -v pkg_aliases[$pkg] ]]; then
|
|
debug "Aliasing $pkg to ${pkg_aliases[$pkg]}"
|
|
pkg=${pkg_aliases[$pkg]}
|
|
fi
|
|
if (( no_install_check )) \
|
|
|| ! { command -v "$pkg" &>/dev/null \
|
|
|| "${PKG_QUERY[@]}" "$pkg" &>/dev/null; }; then
|
|
pkg_array+=("$pkg")
|
|
else
|
|
debug "$pkg already installed, skipping installation"
|
|
fi
|
|
done
|
|
|
|
# Generate installation flags based on the distribution
|
|
case $ID in
|
|
debian|ubuntu)
|
|
(( allow_downgrades )) && install_flags+=(--allow-downgrades)
|
|
;;
|
|
fedora|centos)
|
|
(( allow_downgrades )) && install_flags+=(--allowerasing)
|
|
(( no_gpg_check )) && install_flags+=(--nogpgcheck)
|
|
(( refresh )) && install_flags+=(--refresh)
|
|
;;
|
|
suse)
|
|
(( no_gpg_check )) && install_flags+=(--allow-unsigned-rpm)
|
|
;;
|
|
esac
|
|
|
|
# Install packages if any need installation
|
|
if [[ ${#pkg_array[@]} -gt 0 ]]; then
|
|
if ! "${PKG_INSTALL[@]}" "${install_flags[@]}" "${pkg_array[@]}"; then
|
|
(( silent )) || err "Failed to install ${pkg_array[*]}."
|
|
return 1
|
|
fi
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs mesa-va-drivers-freeworld
|
|
#######################################
|
|
install_mesa_freeworld() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
swap_or_install_freeworld_package() {
|
|
local pkg=$1
|
|
local freeworld_pkg="${pkg}-freeworld"
|
|
|
|
if ! "${PKG_QUERY[@]}" "$freeworld_pkg" &>/dev/null; then
|
|
if "${PKG_QUERY[@]}" "$pkg" &>/dev/null; then
|
|
if ! execute sudo dnf swap -y "$pkg" "$freeworld_pkg"; then
|
|
err "Package swap failed for $pkg!"
|
|
fi
|
|
else
|
|
execute "${PKG_INSTALL[@]}" "$freeworld_pkg"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
swap_or_install_freeworld_package "mesa-va-drivers"
|
|
swap_or_install_freeworld_package "mesa-vdpau-drivers"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs JRiver Media Center from a remote repository
|
|
#######################################
|
|
install_mc_repo() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local deb_repo_file="/etc/apt/sources.list.d/jriver.list"
|
|
local rpm_repo_file="/etc/yum.repos.d/jriver.repo"
|
|
|
|
case $ID in
|
|
fedora|centos)
|
|
sudo bash -c "cat <<-EOF > $rpm_repo_file
|
|
[jriver]
|
|
name=JRiver Media Center repo by BryanC
|
|
baseurl=https://repos.bryanroessler.com/jriver
|
|
gpgcheck=0
|
|
EOF"
|
|
# Install mesa-va-drivers-freeworld separately from the RPM using dnf swap
|
|
install_mesa_freeworld
|
|
;;
|
|
debian|ubuntu)
|
|
install_package wget
|
|
debug "Adding MC repository to $deb_repo_file"
|
|
sudo bash -c "cat <<-EOF > $deb_repo_file
|
|
deb [trusted=yes arch=amd64,i386,armhf,arm64] http://dist.jriver.com/latest/mediacenter/ ${MC_REPO:-$MC_DEFAULT_REPO} main
|
|
EOF"
|
|
debug "Installing JRiver Media Center RPM key"
|
|
wget -qO- "http://dist.jriver.com/mediacenter@jriver.com.gpg.key" |
|
|
sudo tee /etc/apt/trusted.gpg.d/jriver.asc &>/dev/null
|
|
;;
|
|
*)
|
|
err "An MC repository for $ID is not yet available"
|
|
err "Use --install local to install MC on $ID"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
if ! "${PKG_UPDATE[@]}"; then
|
|
err "Package update failed!"
|
|
return 1
|
|
fi
|
|
|
|
if ! install_package \
|
|
--no-install-check \
|
|
--allow-downgrades \
|
|
--no-gpg-check \
|
|
"$MC_PKG"; then
|
|
err "Package install failed!"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Acquires the source DEB package from JRiver
|
|
#######################################
|
|
acquire_deb() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
declare -g MC_DEB="$OUTPUT_DIR/SOURCES/MediaCenter-$MC_VERSION-$ARCH.deb"
|
|
debug "MC_DEB=$MC_DEB"
|
|
|
|
# If deb file already exists, skip download
|
|
if [[ -f $MC_DEB ]]; then
|
|
echo "Using existing DEB: $MC_DEB"
|
|
return 0
|
|
fi
|
|
|
|
# Define the repositories to check
|
|
local repos=(
|
|
"beta/$BETAPASS"
|
|
"latest"
|
|
"test"
|
|
)
|
|
|
|
# Loop through the repositories and attempt to download
|
|
for repo in "${repos[@]}"; do
|
|
echo "Checking $repo repo for DEB package"
|
|
if execute wget --quiet --output-document "$MC_DEB" \
|
|
"https://files.jriver-cdn.com/mediacenter/channels/v$MC_VERSION/$repo/MediaCenter-$MC_VERSION-$ARCH.deb"; then
|
|
echo "Found!"
|
|
break
|
|
fi
|
|
done
|
|
|
|
[[ -f $MC_DEB ]]
|
|
}
|
|
|
|
|
|
|
|
#######################################
|
|
# Creates a SPEC file and builds the RPM from the source DEB using rpmbuild
|
|
#######################################
|
|
build_rpm() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local i rpmbuild_cmd
|
|
local -a requires recommends
|
|
|
|
# skip rebuilding the rpm if it already exists
|
|
if [[ -f $MC_RPM ]]; then
|
|
echo "$MC_RPM already exists. Skipping build step"
|
|
return 0
|
|
fi
|
|
|
|
# Load deb dependencies into array
|
|
IFS=',' read -ra requires <<< "$(dpkg-deb -f "$MC_DEB" Depends)"
|
|
IFS=',' read -ra recommends <<< "$(dpkg-deb -f "$MC_DEB" Recommends)"
|
|
|
|
# Clean up formatting
|
|
requires=("${requires[@]%%|*}")
|
|
requires=("${requires[@]/?:/}")
|
|
requires=("${requires[@]# }")
|
|
requires=("${requires[@]% }")
|
|
requires=("${requires[@]//\(/}")
|
|
requires=("${requires[@]//)/}")
|
|
recommends=("${recommends[@]%%|*}")
|
|
recommends=("${recommends[@]/?:/}")
|
|
recommends=("${recommends[@]# }")
|
|
recommends=("${recommends[@]% }")
|
|
recommends=("${recommends[@]//\(/}")
|
|
recommends=("${recommends[@]//)/}")
|
|
|
|
# Translate package names
|
|
case $BUILD_TARGET in
|
|
fedora|centos)
|
|
requires=("${requires[@]/libc6/glibc}")
|
|
requires=("${requires[@]/libasound2/alsa-lib}")
|
|
requires=("${requires[@]/libuuid1/libuuid}")
|
|
requires=("${requires[@]/libx11-6/libX11}")
|
|
requires=("${requires[@]/libxext6/libXext}")
|
|
requires=("${requires[@]/libxcb1*/libxcb}") # TODO Remove minimum version for MC31 (*)
|
|
requires=("${requires[@]/libxdmcp6/libXdmcp}")
|
|
requires=("${requires[@]/libstdc++6/libstdc++}")
|
|
requires=("${requires[@]/libgtk-3-0/gtk3}")
|
|
requires=("${requires[@]/libgl1/mesa-libGL}")
|
|
requires=("${requires[@]/libpango-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangoft2-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangox-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangoxft-1.0-0/pango}")
|
|
requires=("${requires[@]/libnss3/nss}")
|
|
requires=("${requires[@]/libnspr4/nspr}")
|
|
requires=("${requires[@]/libgomp1/libgomp}")
|
|
requires=("${requires[@]/libfribidi0/fribidi}")
|
|
requires=("${requires[@]/libfontconfig1/fontconfig}")
|
|
requires=("${requires[@]/libfreetype6/freetype}")
|
|
requires=("${requires[@]/libharfbuzz0b/harfbuzz}")
|
|
requires=("${requires[@]/libgbm1/mesa-libgbm}")
|
|
requires=("${requires[@]/libva2/libva}")
|
|
requires=("${requires[@]/libva-drm2/libva}")
|
|
requires=("${requires[@]/libepoxy0/libepoxy}")
|
|
requires=("${requires[@]/liblcms2-2/lcms2}")
|
|
requires=("${requires[@]/libvulkan1/vulkan-loader}")
|
|
requires=("${requires[@]/libepoxy0/libepoxy}")
|
|
requires=("${requires[@]/python/python3}")
|
|
requires=("${requires[@]/libwebkit2gtk*/webkit2gtk4.0}")
|
|
recommends+=(mesa-va-drivers-freeworld)
|
|
;;
|
|
suse)
|
|
requires=("${requires[@]/libc6/glibc}")
|
|
requires=("${requires[@]/libasound2/alsa-lib}")
|
|
requires=("${requires[@]/libx11-6/libX11-6}")
|
|
requires=("${requires[@]/libxext6/libXext6}")
|
|
requires=("${requires[@]/libxdmcp6/libXdmcp6}")
|
|
requires=("${requires[@]/libgtk-3-0/gtk3}")
|
|
requires=("${requires[@]/libgl1/Mesa-libGL1}")
|
|
requires=("${requires[@]/libpango-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangoft2-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangox-1.0-0/pango}")
|
|
requires=("${requires[@]/libpangoxft-1.0-0/pango}")
|
|
requires=("${requires[@]/libnss3/mozilla-nss}")
|
|
requires=("${requires[@]/libnspr4/mozilla-nspr}")
|
|
requires=("${requires[@]/libfribidi0/fribidi}")
|
|
requires=("${requires[@]/libfontconfig1/fontconfig}")
|
|
requires=("${requires[@]/libharfbuzz0b/libharfbuzz0}")
|
|
requires=("${requires[@]/libwebkit2gtk*/libwebkit2gtk-4_0-37}")
|
|
for i in "${!requires[@]}"; do
|
|
[[ ${requires[$i]} == "mesa-vulkan-drivers" ]] && unset -v 'requires[i]'
|
|
done
|
|
recommends+=(libvulkan_intel)
|
|
recommends+=(libvulkan_radeon)
|
|
;;
|
|
esac
|
|
|
|
# Convert array to newline delim'd string (for heredoc)
|
|
printf -v requires "Requires: %s\n" "${requires[@]}"
|
|
printf -v recommends "Recommends: %s\n" "${recommends[@]}"
|
|
# Strip last newline
|
|
requires="${requires%?}"
|
|
recommends="${recommends%?}"
|
|
|
|
if (( COMPAT_SWITCH )); then
|
|
# Strip minimum versions
|
|
requires=$(echo "$requires" | awk -F" " 'NF == 4 {print $1 " " $2} NF != 4 {print $0}')
|
|
fi
|
|
|
|
# Create spec file
|
|
cat <<-EOF > "$OUTPUT_DIR/SPECS/mediacenter.spec"
|
|
Name: mediacenter$MC_MVERSION
|
|
Version: $MC_VERSION
|
|
Release: 1
|
|
Summary: JRiver Media Center
|
|
Group: Applications/Media
|
|
Source0: http://files.jriver-cdn.com/mediacenter/channels/v$MC_MVERSION/latest/MediaCenter-$MC_VERSION-$ARCH.deb
|
|
BuildArch: x86_64
|
|
%define _rpmfilename %%{ARCH}/%%{NAME}-%%{version}.%%{ARCH}.rpm
|
|
|
|
AutoReq: 0
|
|
|
|
$requires
|
|
$recommends
|
|
|
|
Conflicts: MediaCenter
|
|
|
|
Provides: mediacenter$MC_MVERSION
|
|
|
|
License: Copyright 1998-2024, JRiver, Inc. All rights reserved. Protected by U.S. patents #7076468 and #7062468
|
|
URL: http://www.jriver.com/
|
|
|
|
%define __provides_exclude_from ^%{_libdir}/jriver/.*/.*\\.so.*$
|
|
|
|
%description
|
|
Media Center is more than a world class player.
|
|
|
|
%global __os_install_post %{nil}
|
|
%prep
|
|
|
|
%build
|
|
|
|
%install
|
|
dpkg -x %{S:0} %{buildroot}
|
|
|
|
%post -p /sbin/ldconfig
|
|
%postun -p /sbin/ldconfig
|
|
|
|
%files
|
|
%{_bindir}/mediacenter$MC_MVERSION
|
|
%{_bindir}/mc$MC_MVERSION
|
|
%{_libdir}/jriver
|
|
%{_datadir}
|
|
%exclude %{_datadir}/applications/media_center_packageinstaller_$MC_MVERSION.desktop
|
|
/etc/security/limits.d/*
|
|
EOF
|
|
|
|
# Run rpmbuild
|
|
echo "Building MC $MC_VERSION RPM, this may take some time"
|
|
rpmbuild_cmd=(
|
|
rpmbuild
|
|
--define="%_topdir $OUTPUT_DIR"
|
|
--define="%_libdir /usr/lib"
|
|
-bb
|
|
"$OUTPUT_DIR/SPECS/mediacenter.spec"
|
|
)
|
|
if execute "${rpmbuild_cmd[@]}" && [[ -f $MC_RPM ]] ; then
|
|
echo "Build successful. The RPM file is located at: $MC_RPM"
|
|
else
|
|
err "Build failed"
|
|
# For automation, let's remove the source DEB and reaquire it on next
|
|
# run after failure in case it is corrupted or buggy
|
|
[[ -f $MC_DEB ]] && echo "Removing source DEB" && rm -f "$MC_DEB"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs Media Center DEB package and optional compatability fixes
|
|
#######################################
|
|
install_mc_deb() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
if (( COMPAT_SWITCH )); then
|
|
declare extract_dir && extract_dir="$(mktemp -d)"
|
|
pushd "$extract_dir" &>/dev/null || return
|
|
command -v ar &>/dev/null || install_package binutils
|
|
execute ar x "$MC_DEB"
|
|
execute tar xJf "control.tar.xz"
|
|
# Remove minimum version specifiers from control file
|
|
sed -i 's/ ([^)]*)//g' "control"
|
|
|
|
# TODO ugly ZorinOS workaround
|
|
[[ $ID == "ubuntu" && ${VERSION_ID%.*} -le 16 ]] \
|
|
&& ! grep -q zorin /etc/os-release \
|
|
&& sed -i 's/libva2/libva1/g' "control"
|
|
|
|
execute tar -cJf "control.tar.xz" "control" "postinst"
|
|
declare -g MC_DEB="${MC_DEB/.deb/.compat.deb}"
|
|
execute ar rcs "$MC_DEB" "debian-binary" "control.tar.xz" "data.tar.xz"
|
|
popd &>/dev/null || return
|
|
execute rm -rf "$extract_dir"
|
|
fi
|
|
|
|
install_package \
|
|
--no-install-check \
|
|
--no-gpg-check \
|
|
--allow-downgrades \
|
|
"$MC_DEB"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs Media Center RPM package
|
|
#######################################
|
|
install_mc_rpm() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
# Install mesa-va-freeworld separately from the RPM for dnf swap
|
|
install_mesa_freeworld
|
|
|
|
install_package --no-install-check --no-gpg-check --allow-downgrades "$MC_RPM"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs Media Center manually
|
|
#######################################
|
|
install_mc_generic() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local -a raw_files
|
|
|
|
echo "Using generic installation method!"
|
|
|
|
declare extract_dir && extract_dir="$(mktemp -d)"
|
|
pushd "$extract_dir" &>/dev/null || return
|
|
execute ar x "$MC_DEB"
|
|
execute tar xJf "control.tar.xz"
|
|
echo "You must install the following dependencies manually:"
|
|
grep -i "Depends:" control
|
|
readarray -t raw_files < <(tar xJvf data.tar.xz)
|
|
# Output to log file
|
|
for f in "${raw_files[@]/#./}"; do
|
|
echo "$f" >> "$SCRIPT_DIR/.uninstall"
|
|
done
|
|
# Manually install files
|
|
for f in "${raw_files[@]}"; do
|
|
execute sudo cp -a "$f" "${f/#./}"
|
|
done
|
|
popd &>/dev/null || return
|
|
execute rm -rf "$extract_dir"
|
|
return 0
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Installs local Media Center PKGBUILD
|
|
#######################################
|
|
install_mc_arch() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
[[ -d $OUTPUT_DIR/PKGBUILD ]] || execute mkdir -p "$OUTPUT_DIR/PKGBUILD"
|
|
|
|
cat <<-EOF > "$OUTPUT_DIR/PKGBUILD/mediacenter.pkgbuild"
|
|
pkgname=mediacenter$MC_MVERSION
|
|
pkgver=$MC_VERSION
|
|
pkgrel=1
|
|
pkgdesc="The Most Comprehensive Media Software"
|
|
arch=('x86_64')
|
|
url="http://www.jriver.com/"
|
|
license=('custom')
|
|
depends=('alsa-lib' 'gcc-libs' 'libx11' 'libxext' 'libxcb' 'libxau' 'libxdmcp' 'util-linux' 'libxext' 'gtk3')
|
|
optdepends=(
|
|
'mesa-libgl: nouveau video support'
|
|
'nvidia-libgl: nvidia video support'
|
|
'nvidia-utils: nvidia vulkan support'
|
|
'vulkan-intel: intel vulkan support'
|
|
'vulkan-radeon: amd vulkan support'
|
|
'vorbis-tools: ogg vorbis support'
|
|
'musepack-tools: musepack support'
|
|
)
|
|
source=("http://files.jriver-cdn.com/mediacenter/channels/v$MC_MVERSION/latest/MediaCenter-$MC_VERSION-$ARCH.deb")
|
|
|
|
package() {
|
|
cd "\$srcdir"
|
|
bsdtar xf data.tar.xz -C "\$pkgdir"
|
|
}
|
|
EOF
|
|
|
|
pushd "$OUTPUT_DIR/PKGBUILD" &>/dev/null || return
|
|
|
|
if ! execute makepkg \
|
|
--install \
|
|
--syncdeps \
|
|
--clean \
|
|
--cleanbuild \
|
|
--skipinteg \
|
|
--force \
|
|
--noconfirm \
|
|
-p mediacenter.pkgbuild; then
|
|
echo "makepkg failed"
|
|
exit 1
|
|
fi
|
|
|
|
popd &>/dev/null || return
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Copy the RPM to createrepo-webroot and runs createrepo as the createrepo-user
|
|
#######################################
|
|
run_createrepo() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local -a cr_cmd
|
|
|
|
install_package createrepo_c
|
|
|
|
# Ensure the webroot exists
|
|
if [[ ! -d $CREATEREPO_WEBROOT ]]; then
|
|
if ! execute sudo -u "$CREATEREPO_USER" mkdir -p "$CREATEREPO_WEBROOT"; then
|
|
if ! execute sudo mkdir -p "$CREATEREPO_WEBROOT" &&
|
|
! execute sudo chown -R "$CREATEREPO_USER:$CREATEREPO_USER" "$CREATEREPO_WEBROOT"; then
|
|
err "Could not create the createrepo-webroot path!"
|
|
err "Make sure that the webroot $CREATEREPO_WEBROOT is writable by user $CREATEREPO_USER"
|
|
err "Or change the repo ownership with --createrepo-user"
|
|
return 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Copy built RPMs to webroot
|
|
if ! execute sudo cp -nf "$MC_RPM" "$CREATEREPO_WEBROOT" ||
|
|
! execute sudo chown -R "$CREATEREPO_USER:$CREATEREPO_USER" "$CREATEREPO_WEBROOT"; then
|
|
err "Could not copy $MC_RPM to $CREATEREPO_WEBROOT"
|
|
return 1
|
|
fi
|
|
|
|
# Run createrepo
|
|
cr_cmd=(sudo -u "$CREATEREPO_USER" createrepo -q "$CREATEREPO_WEBROOT")
|
|
[[ -d $CREATEREPO_WEBROOT/repodata ]] && cr_cmd+=(--update)
|
|
|
|
if ! execute "${cr_cmd[@]}"; then
|
|
cr_cmd=(sudo createrepo -q "$CREATEREPO_WEBROOT")
|
|
[[ -d $CREATEREPO_WEBROOT/repodata ]] && cr_cmd+=(--update)
|
|
|
|
if ! execute "${cr_cmd[@]}" ||
|
|
! execute sudo chown -R "$CREATEREPO_USER:$CREATEREPO_USER" "$CREATEREPO_WEBROOT"; then
|
|
err "createrepo failed"
|
|
return 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Symlink certificates if they do not exist in default location
|
|
#######################################
|
|
link_ssl_certs() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local target_cert f
|
|
local mc_cert_link="$MC_ROOT/ca-certificates.crt"
|
|
local -a source_certs=(
|
|
"/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem"
|
|
"/var/lib/ca-certificates/ca-bundle.pem")
|
|
|
|
target_cert=$(readlink -f "$mc_cert_link")
|
|
[[ -f $target_cert ]] && return 0
|
|
|
|
for f in "${source_certs[@]}"; do
|
|
if [[ -f $f ]]; then
|
|
if ! execute sudo ln -fs "$f" "$mc_cert_link"; then
|
|
err "Symlinking certificate failed"
|
|
return 1
|
|
fi
|
|
break
|
|
fi
|
|
done
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Restore the mjr license file from MJR_RESTORE_FILE or other common locations
|
|
#######################################
|
|
restore_license() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local f newest mjrfiles
|
|
|
|
# Glob mjr files from common directories
|
|
shopt -s nullglob
|
|
mjrfiles=(
|
|
"$SCRIPT_DIR"/*.mjr
|
|
"$OUTPUT_DIR"/*.mjr
|
|
"$HOME"/[dD]ownloads/*.mjr
|
|
"$HOME"/[dD]ocuments/*.mjr
|
|
)
|
|
shopt -u nullglob
|
|
|
|
if [[ ${#mjrfiles[@]} -gt 0 ]]; then
|
|
|
|
debug "mjrfiles=(${mjrfiles[*]})"
|
|
|
|
# Sort globbed files by time, newest first
|
|
newest=${mjrfiles[0]}
|
|
for f in "${mjrfiles[@]}"; do
|
|
if [[ -f $f && $f -nt $newest ]]; then
|
|
newest=$f
|
|
fi
|
|
done
|
|
|
|
debug "Latest mjrfile: $newest"
|
|
|
|
for f in "$MJR_RESTORE_FILE" "$newest"; do
|
|
if [[ -f $f ]]; then
|
|
execute "mediacenter$MC_MVERSION" "/RestoreFromFile" "$f"
|
|
fi
|
|
done
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Opens ports using the system firewall tool
|
|
# Arguments:
|
|
# 1. Service name
|
|
# 2. List of ports in firewall-cmd format
|
|
#######################################
|
|
open_firewall() {
|
|
debug "Running: ${FUNCNAME[0]}" "$@"
|
|
|
|
local port
|
|
local service="$1"
|
|
shift
|
|
local -a f_ports=("$@") # for firewall-cmd
|
|
local u_ports="$*"
|
|
u_ports="${u_ports// /|}" # concatenate
|
|
u_ports="${u_ports//-/\:}" # for ufw
|
|
|
|
if command -v firewall-cmd &>/dev/null; then
|
|
if ! sudo firewall-cmd --get-services | grep -q "$service"; then
|
|
execute sudo firewall-cmd --permanent "--new-service=$service"
|
|
execute sudo firewall-cmd --permanent "--service=$service" "--set-description=$service" installed by installJRMC
|
|
execute sudo firewall-cmd --permanent "--service=$service" "--set-short=$service"
|
|
for port in "${f_ports[@]}"; do
|
|
execute sudo firewall-cmd --permanent "--service=$service" "--add-port=$port"
|
|
done
|
|
execute sudo firewall-cmd --add-service "$service" --permanent
|
|
execute sudo firewall-cmd --reload
|
|
fi
|
|
elif command -v ufw &>/dev/null; then
|
|
sudo bash -c "cat <<-EOF > /etc/ufw/applications.d/$service
|
|
[$service]
|
|
title=$service
|
|
description=$service installed by installJRMC
|
|
ports=$u_ports
|
|
EOF"
|
|
execute sudo ufw app update "$service"
|
|
execute sudo ufw allow "$service"
|
|
else
|
|
echo "Warning: Install firewall-cmd or ufw to open firewall ports"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Create the xvnc or x11vnc password file
|
|
# Arguments:
|
|
# Service type (xvnc, x11vnc)
|
|
#######################################
|
|
set_vnc_pass() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local vncpassfile="$HOME/.vnc/jrmc_passwd"
|
|
|
|
[[ -d ${vncpassfile%/*} ]] || execute mkdir -p "${vncpassfile%/*}"
|
|
|
|
if [[ -f $vncpassfile ]]; then
|
|
if [[ ! -v VNCPASS ]]; then
|
|
err "Refusing to overwrite existing $vncpassfile with an empty password"
|
|
err "Remove existing $vncpassfile or use --vncpass ''"
|
|
return 1
|
|
else
|
|
execute rm -f "$vncpassfile"
|
|
fi
|
|
fi
|
|
|
|
if [[ -v VNCPASS ]]; then
|
|
if [[ $1 == "xvnc" ]]; then
|
|
echo "$VNCPASS" | vncpasswd -f > "$vncpassfile"
|
|
elif [[ $1 == "x11vnc" ]]; then
|
|
execute x11vnc -storepasswd "$VNCPASS" "$vncpassfile"
|
|
fi
|
|
return $?
|
|
else
|
|
declare -g NOVNCAUTH=1
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Set display and port variables
|
|
#######################################
|
|
set_display_vars() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
declare -g THIS_DISPLAY THIS_DISPLAY_NUM NEXT_DISPLAY
|
|
|
|
# Check USER_DISPLAY, else environment DISPLAY, else set to :0
|
|
THIS_DISPLAY="${USER_DISPLAY:-${DISPLAY:-:0}}"
|
|
THIS_DISPLAY_NUM="${THIS_DISPLAY#*:}" # strip prefix
|
|
THIS_DISPLAY_NUM="${THIS_DISPLAY_NUM%%.*}" # strip suffix
|
|
# Increment each time we run this
|
|
if (( NEXT_DISPLAY_NUM )); then
|
|
declare -g NEXT_DISPLAY_NUM=$(( NEXT_DISPLAY_NUM + 1 ))
|
|
else
|
|
declare -g NEXT_DISPLAY_NUM=$(( THIS_DISPLAY_NUM + 1 ))
|
|
fi
|
|
NEXT_DISPLAY=":$NEXT_DISPLAY_NUM"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Create associated service variables based on service name
|
|
# Arguments
|
|
# Pre-defined service name
|
|
#######################################
|
|
set_service_vars() {
|
|
debug "Running: ${FUNCNAME[0]}" "$*"
|
|
|
|
declare -g SERVICE_NAME SERVICE_FNAME TIMER_NAME TIMER_FNAME
|
|
declare -g USER_STRING DISPLAY_STRING GRAPHICAL_TARGET
|
|
declare -ga RELOAD ENABLE DISABLE IS_ENABLED IS_ACTIVE
|
|
local -a systemctl_prefix
|
|
local service_name="$1"
|
|
local service_type="${SERVICE_TYPE:-${2:-system}}"
|
|
local service_dir="/usr/lib/systemd/$service_type"
|
|
|
|
if [[ $USER == "root" && $service_type == "user" ]]; then
|
|
err "Trying to install user service as root"
|
|
err "Use --service-type service and/or execute installJRMC as non-root user"
|
|
return 1
|
|
fi
|
|
|
|
if [[ $service_type == "system" ]]; then
|
|
systemctl_prefix=(sudo systemctl)
|
|
GRAPHICAL_TARGET="graphical.target"
|
|
elif [[ $service_type == "user" ]]; then
|
|
systemctl_prefix=(systemctl --user)
|
|
GRAPHICAL_TARGET="default.target"
|
|
fi
|
|
|
|
# systemctl commands
|
|
RELOAD=(execute "${systemctl_prefix[@]}" daemon-reload)
|
|
ENABLE=(execute "${systemctl_prefix[@]}" enable --now)
|
|
DISABLE=(execute "${systemctl_prefix[@]}" disable --now)
|
|
IS_ENABLED=(execute "${systemctl_prefix[@]}" is-enabled -q)
|
|
IS_ACTIVE=(execute "${systemctl_prefix[@]}" is-active -q)
|
|
|
|
[[ -d $service_dir ]] || execute sudo mkdir -p "$service_dir"
|
|
|
|
# TODO Ubuntu needs these in the service file, fedora (and others?) do not
|
|
case $ID in
|
|
ubuntu|debian)
|
|
DISPLAY_STRING="Environment=XAUTHORITY=${XAUTHORITY:-$(echo /run/user/"$(id -u)"/.mutter*)}"
|
|
;;
|
|
*)
|
|
DISPLAY_STRING=""
|
|
;;
|
|
esac
|
|
|
|
if [[ $service_type == "system" && $USER != "root" ]]; then
|
|
SERVICE_FNAME="$service_dir/$service_name@.service"
|
|
TIMER_FNAME="$service_dir/$service_name@.timer"
|
|
SERVICE_NAME="$service_name@$USER.service"
|
|
TIMER_NAME="$service_name@$USER.timer"
|
|
USER_STRING="User=%I"
|
|
else
|
|
SERVICE_NAME="$service_name.service"
|
|
TIMER_NAME="$service_name.timer"
|
|
SERVICE_FNAME="$service_dir/$SERVICE_NAME"
|
|
TIMER_FNAME="$service_dir/${TIMER_NAME}"
|
|
USER_STRING=""
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Starts and enables (at startup) a JRiver Media Center service
|
|
# Arguments:
|
|
# Passes arguments as startup options to /usr/bin/mediacenter??
|
|
#######################################
|
|
service_jriver-mediacenter() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
set_service_vars "${FUNCNAME[0]##*_}" "user"
|
|
|
|
sudo bash -c "cat <<-EOF > $SERVICE_FNAME
|
|
[Unit]
|
|
Description=JRiver Media Center $MC_MVERSION
|
|
After=$GRAPHICAL_TARGET
|
|
|
|
[Service]
|
|
Type=simple
|
|
$USER_STRING
|
|
$DISPLAY_STRING
|
|
Environment=DISPLAY=$THIS_DISPLAY
|
|
ExecStart=/usr/bin/mediacenter$MC_MVERSION $*
|
|
KillMode=none
|
|
ExecStop=/usr/bin/mc$MC_MVERSION /MCC 20007
|
|
Restart=always
|
|
RestartSec=10
|
|
TimeoutStopSec=30
|
|
|
|
[Install]
|
|
WantedBy=$GRAPHICAL_TARGET
|
|
EOF"
|
|
|
|
open_firewall "jriver-mediacenter" "52100-52200/tcp" "1900/udp"
|
|
|
|
"${RELOAD[@]}" \
|
|
&& "${ENABLE[@]}" "$SERVICE_NAME"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Starts and enables (at startup) a JRiver Media Server service
|
|
#######################################
|
|
service_jriver-mediaserver() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
set_service_vars "${FUNCNAME[0]##*_}" "user"
|
|
|
|
service_jriver-mediacenter "/MediaServer"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Starts and enables (at startup) JRiver Media Center in a new Xvnc session
|
|
# TODO https://github.com/TigerVNC/tigervnc/blob/master/unix/vncserver/HOWTO.md
|
|
#######################################
|
|
service_jriver-xvnc() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
set_service_vars "${FUNCNAME[0]##*_}" "system"
|
|
set_display_vars
|
|
local -a start_cmd
|
|
declare -g PORT=$(( NEXT_DISPLAY_NUM + 5900 ))
|
|
|
|
install_package tigervnc-server
|
|
|
|
set_vnc_pass xvnc
|
|
|
|
start_cmd=(
|
|
/usr/bin/vncserver "$NEXT_DISPLAY"
|
|
-geometry 1440x900
|
|
-alwaysshared
|
|
-autokill
|
|
-xstartup "/usr/bin/mediacenter$MC_MVERSION"
|
|
)
|
|
|
|
if (( NOVNCAUTH )); then
|
|
start_cmd+=(
|
|
-name "jriver$NEXT_DISPLAY"
|
|
-SecurityTypes None)
|
|
else
|
|
start_cmd+=(
|
|
-rfbauth "$HOME/.vnc/jrmc_passwd")
|
|
fi
|
|
|
|
sudo bash -c "cat <<-EOF > $SERVICE_FNAME
|
|
[Unit]
|
|
Description=Remote desktop service (VNC)
|
|
After=multi-user.target
|
|
|
|
[Service]
|
|
Type=forking
|
|
$USER_STRING
|
|
ExecStartPre=/bin/sh -c '/usr/bin/vncserver -kill $NEXT_DISPLAY &>/dev/null || :'
|
|
ExecStart=${start_cmd[*]}
|
|
ExecStop=/usr/bin/vncserver -kill $NEXT_DISPLAY
|
|
Restart=always
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF"
|
|
|
|
"${RELOAD[@]}"
|
|
|
|
if ! "${ENABLE[@]}" "$SERVICE_NAME"; then
|
|
err "vncserver failed to start on DISPLAY $NEXT_DISPLAY"
|
|
# Allow to increment 10 times before breaking
|
|
max=$(( THIS_DISPLAY_NUM + 10 ))
|
|
while [[ $NEXT_DISPLAY_NUM -lt $max ]]; do
|
|
echo "Incrementing DISPLAY and retrying"
|
|
service_jriver-xvnc && return
|
|
done
|
|
return 1
|
|
else
|
|
echo "Xvnc running on localhost:$PORT"
|
|
open_firewall "jriver-xvnc" "$PORT/tcp"
|
|
open_firewall "jriver-mediacenter" "52100-52200/tcp" "1900/udp"
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Starts and enables (at startup) x11vnc screen sharing for the local desktop
|
|
#######################################
|
|
service_jriver-x11vnc() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
set_service_vars "${FUNCNAME[0]##*_}" "user"
|
|
set_display_vars
|
|
|
|
local -a start_cmd
|
|
declare -g PORT=$(( THIS_DISPLAY_NUM + 5900 ))
|
|
|
|
install_package x11vnc
|
|
|
|
set_vnc_pass x11vnc
|
|
|
|
# If .Xauthority file is missing, generate a dummy for x11vnc -auth guess
|
|
if [[ ! -f "$HOME/.Xauthority" ]]; then
|
|
[[ $XDG_SESSION_TYPE == "wayland" ]] &&
|
|
ask_ok "Unsupported Wayland session detected for x11vnc, continue?" || return 1
|
|
debug "Generating $HOME/.Xauthority"
|
|
execute touch "$HOME/.Xauthority"
|
|
execute chmod 644 "$HOME/.Xauthority"
|
|
xauth generate "$DISPLAY" . trusted
|
|
xauth add "$HOST$DISPLAY" . "$(xxd -l 16 -p /dev/urandom)"
|
|
fi
|
|
|
|
start_cmd=(
|
|
/usr/bin/x11vnc
|
|
-display "$DISPLAY"
|
|
-noscr
|
|
-auth guess
|
|
-forever
|
|
-bg
|
|
)
|
|
|
|
if (( NOVNCAUTH )); then
|
|
start_cmd+=(-nopw)
|
|
else
|
|
start_cmd+=(-rfbauth "$HOME/.vnc/jrmc_passwd")
|
|
fi
|
|
|
|
sudo bash -c "cat <<-EOF > $SERVICE_FNAME
|
|
[Unit]
|
|
Description=x11vnc
|
|
After=$GRAPHICAL_TARGET
|
|
|
|
[Service]
|
|
$USER_STRING
|
|
Type=forking
|
|
Environment=DISPLAY=$DISPLAY
|
|
ExecStart=${start_cmd[*]}
|
|
Restart=always
|
|
RestartSec=10
|
|
|
|
[Install]
|
|
WantedBy=$GRAPHICAL_TARGET
|
|
EOF"
|
|
|
|
open_firewall "jriver-x11vnc" "$PORT/tcp"
|
|
|
|
"${RELOAD[@]}" \
|
|
&& "${ENABLE[@]}" "$SERVICE_NAME" \
|
|
&& echo "x11vnc running on localhost:$PORT"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Starts and enables (at startup) an hourly service to build the latest version of
|
|
# JRiver Media Center RPM from the source DEB and create/update an RPM repository
|
|
#######################################
|
|
service_jriver-createrepo() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
if [[ $CREATEREPO_USER != "$USER" ]]; then
|
|
USER="root" set_service_vars "${FUNCNAME[0]##*_}" "system"
|
|
else
|
|
set_service_vars "${FUNCNAME[0]##*_}" "system"
|
|
fi
|
|
|
|
sudo bash -c "cat <<-EOF > $SERVICE_FNAME
|
|
[Unit]
|
|
Description=Builds JRiver Media Center RPM, moves it to the repo dir, and runs createrepo
|
|
|
|
[Service]
|
|
$USER_STRING
|
|
ExecStart=$SCRIPT_DIR/installJRMC --outputdir=$OUTPUT_DIR --createrepo=$REPO_TARGET --createrepo-webroot=$CREATEREPO_WEBROOT --createrepo-user=$CREATEREPO_USER
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF"
|
|
|
|
sudo bash -c "cat <<-EOF > $TIMER_FNAME
|
|
[Unit]
|
|
Description=Run JRiver MC rpmbuild hourly
|
|
|
|
[Timer]
|
|
OnCalendar=hourly
|
|
Persistent=true
|
|
|
|
[Install]
|
|
WantedBy=timers.target
|
|
EOF"
|
|
|
|
"${RELOAD[@]}" \
|
|
&& "${ENABLE[@]}" "$TIMER_NAME"
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Detects if MC is installed on btrfs and disables CoW
|
|
#######################################
|
|
disable_btrfs_cow() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local dir
|
|
local mc_user_path="$HOME/.jriver"
|
|
|
|
for dir in "$MC_ROOT" "$mc_user_path"; do
|
|
[[ -d $dir ]] || execute mkdir -p "$dir"
|
|
if [[ $(stat -f -c %T "$dir") == "btrfs" ]] \
|
|
&& ! lsattr -d "$dir" | cut -f1 -d" " | grep -q C \
|
|
&& execute sudo chattr +C "$dir"; then
|
|
echo "Disabled btrfs CoW for $dir directory"
|
|
fi
|
|
done
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Completely uninstalls MC, services, and firewall rules
|
|
#######################################
|
|
uninstall() {
|
|
debug "Running: ${FUNCNAME[0]}"
|
|
|
|
local service unit f i
|
|
|
|
echo "Stopping and removing all Media Center services"
|
|
for service in $(compgen -A "function" "service"); do
|
|
service="${service##service_}"
|
|
for i in user system; do
|
|
set_service_vars "$service" "$i";
|
|
for unit in "$SERVICE_NAME" "$TIMER_NAME"; do
|
|
if "${IS_ACTIVE[@]}" "$unit" ||
|
|
"${IS_ENABLED[@]}" "$unit"; then
|
|
"${DISABLE[@]}" "$unit"
|
|
fi
|
|
done
|
|
for f in "$SERVICE_FNAME" "$TIMER_FNAME"; do
|
|
[[ -f $f ]] &&
|
|
execute sudo rm -f "$f"
|
|
done
|
|
"${RELOAD[@]}"
|
|
unset f
|
|
done
|
|
for f in /etc/systemd/system/jriver-*; do
|
|
execute sudo rm -f "$f"
|
|
done
|
|
unset f
|
|
done
|
|
|
|
echo "Removing repo files"
|
|
sudo rm -rf \
|
|
"/etc/yum.repos.d/jriver.repo" \
|
|
/etc/apt/sources.list.d/{jriver,mediacenter}*.list # also remove legacy repo files
|
|
if [[ $ID == "suse" ]]; then
|
|
execute sudo zypper --non-interactive removerepo jriver
|
|
fi
|
|
|
|
echo "Removing firewall rules"
|
|
if command -v firewall-cmd &>/dev/null; then
|
|
execute sudo firewall-cmd --permanent --remove-service=jriver
|
|
execute sudo firewall-cmd --permanent --delete-service=jriver
|
|
execute sudo firewall-cmd --reload
|
|
elif command -v ufw &>/dev/null; then
|
|
execute sudo ufw delete allow jriver
|
|
[[ -f "/etc/ufw/applications.d/jriver" ]] &&
|
|
execute sudo rm -f /etc/ufw/applications.d/jriver
|
|
fi
|
|
|
|
echo "Uninstalling JRiver Media Center package"
|
|
if "${PKG_REMOVE[@]}" "$MC_PKG"; then
|
|
echo "JRiver Media Center has been completely uninstalled"
|
|
echo "To remove your MC library: rm -rf $HOME/.jriver"
|
|
elif [[ $? -eq 100 ]]; then
|
|
err "JRiver Media Center package '$MC_PKG' is not present and was not uninstalled"
|
|
else
|
|
err "Could not remove Media Center package"
|
|
fi
|
|
|
|
if [[ -f $SCRIPT_DIR/.uninstall ]]; then
|
|
echo "Removing files from .uninstall log"
|
|
while read -r p; do
|
|
[[ -d $p ]] && execute sudo rm -rf "$p"
|
|
done < "$SCRIPT_DIR/.uninstall"
|
|
mv "$SCRIPT_DIR/.uninstall" "$SCRIPT_DIR/.uninstall.bk"
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
|
|
#######################################
|
|
# Checks for installJRMC update and re-executes, if necessary
|
|
#######################################
|
|
update_self() {
|
|
debug "Running: ${FUNCNAME[0]} $*"
|
|
|
|
local script_url="https://git.bryanroessler.com/bryan/installJRMC/raw/master/installJRMC"
|
|
local tmp; tmp=$(mktemp)
|
|
|
|
echo "Checking for installJRMC update"
|
|
|
|
# Function to extract and normalize version from a script
|
|
extract_version() {
|
|
local version_line
|
|
version_line=$(grep -m 1 'SCRIPT_VERSION=' "$1")
|
|
version_line=${version_line#*=}
|
|
version_line=${version_line#\"}
|
|
version_line=${version_line%-dev\"}
|
|
version_line=${version_line%\"}
|
|
echo "$version_line"
|
|
}
|
|
|
|
# Check if we're in a git directory and if it's the installJRMC repository
|
|
if git -C "$SCRIPT_DIR" rev-parse --is-inside-work-tree &>/dev/null \
|
|
&& [[ "$(git -C "$SCRIPT_DIR" config --get remote.origin.url)" == *"bryan/installJRMC"* ]]; then
|
|
debug "installJRMC git repository detected. Running git pull..."
|
|
|
|
# Get the current commit hash
|
|
local before_pull_hash
|
|
before_pull_hash=$(git -C "$SCRIPT_DIR" rev-parse HEAD)
|
|
|
|
if git -C "$SCRIPT_DIR" pull | grep -qv "Already up to date"; then
|
|
return 0
|
|
fi
|
|
|
|
local after_pull_hash
|
|
after_pull_hash=$(git -C "$SCRIPT_DIR" rev-parse HEAD)
|
|
if [[ "$before_pull_hash" != "$after_pull_hash" ]]; then
|
|
echo "installJRMC repository updated. Restarting script..."
|
|
exec "$SCRIPT_PATH" "$@" "--no-self-update"
|
|
fi
|
|
fi
|
|
|
|
# Download the latest version of the script
|
|
install_package --silent wget
|
|
if command -v wget &>/dev/null; then
|
|
execute wget -q -O "$tmp" "$script_url"
|
|
elif command -v curl &>/dev/null; then
|
|
execute curl -s -L -o "$tmp" "$script_url"
|
|
else
|
|
return 1
|
|
fi
|
|
|
|
# Compare versions and update if necessary
|
|
local local_version
|
|
local_version=$(extract_version "$SCRIPT_PATH")
|
|
local remote_version
|
|
remote_version=$(extract_version "$tmp")
|
|
|
|
debug HERE
|
|
|
|
[[ -z $remote_version ]] && { rm -f "$tmp"; return 1; }
|
|
|
|
if [[ $local_version < $remote_version ]]; then
|
|
echo "Newer version of installJRMC found. Updating..."
|
|
execute mv "$tmp" "$SCRIPT_PATH"
|
|
execute chmod +x "$SCRIPT_PATH"
|
|
exec "$SCRIPT_PATH" "$@" "--no-self-update"
|
|
fi
|
|
|
|
rm -f "$tmp"
|
|
}
|
|
|
|
|
|
main() {
|
|
debug "Running: ${FUNCNAME[0]} $*"
|
|
|
|
parse_input "$@"
|
|
|
|
init
|
|
|
|
debug "Debugging on"
|
|
debug "installJRMC version: $SCRIPT_VERSION"
|
|
# ((DEBUG)) && declare -p
|
|
|
|
((SELF_UPDATE)) && update_self "$@"
|
|
|
|
if ((TEST_SWITCH)); then
|
|
echo "Running tests, all other options are skipped"
|
|
tests
|
|
exit
|
|
fi
|
|
|
|
set_mc_version
|
|
|
|
if (( UNINSTALL_SWITCH )); then
|
|
if ask_ok "Do you really want to uninstall JRiver Media Center?"; then
|
|
uninstall
|
|
else
|
|
echo "Uninstall canceled"
|
|
fi
|
|
exit
|
|
fi
|
|
|
|
# Install external repos
|
|
case $ID in
|
|
ubuntu)
|
|
if ! grep ^deb /etc/apt/sources.list | grep -q universe; then
|
|
echo "Adding universe repository"
|
|
if ! execute sudo add-apt-repository -y universe; then
|
|
err "Adding universe repository failed"
|
|
fi
|
|
fi
|
|
;;
|
|
centos)
|
|
if ! command -v dpkg &>/dev/null; then
|
|
echo "Adding EPEL repository"
|
|
install_package epel-release
|
|
fi
|
|
if ! "${PKG_QUERY[@]}" rpmfusion-free-release &>/dev/null; then
|
|
install_package --no-install-check \
|
|
"https://download1.rpmfusion.org/free/el/rpmfusion-free-release-$VERSION_ID.noarch.rpm"
|
|
fi
|
|
;;
|
|
fedora)
|
|
if ! "${PKG_QUERY[@]}" rpmfusion-free-release &>/dev/null; then
|
|
install_package --no-install-check \
|
|
"https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$VERSION_ID.noarch.rpm"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if (( REPO_INSTALL_SWITCH )); then
|
|
echo "Installing JRiver Media Center from remote repository"
|
|
if install_mc_repo; then
|
|
echo "JRiver Media Center installed successfully from remote repository"
|
|
link_ssl_certs
|
|
# migrateLibrary
|
|
restore_license
|
|
open_firewall "jriver-mediacenter" "52100-52200/tcp" "1900/udp"
|
|
disable_btrfs_cow
|
|
else
|
|
err "JRiver Media Center installation from remote repository failed"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
if (( BUILD_SWITCH )) && [[ $ID != "arch" ]]; then
|
|
install_package "wget"
|
|
[[ -d $OUTPUT_DIR/SOURCES ]] || execute mkdir -p "$OUTPUT_DIR/SOURCES"
|
|
acquire_deb || { err "Could not download Media Center DEB package"; return 1; }
|
|
if [[ $BUILD_TARGET =~ (centos|fedora|suse) \
|
|
|| $REPO_TARGET =~ (centos|fedora|suse) ]]; then
|
|
install_package "dpkg" "rpm-build"
|
|
[[ -d $OUTPUT_DIR/SPECS ]] || execute mkdir -p "$OUTPUT_DIR/SPECS"
|
|
build_rpm
|
|
fi
|
|
fi
|
|
|
|
if (( LOCAL_INSTALL_SWITCH )); then
|
|
if PKG_INSTALL_LOCAL; then
|
|
echo "JRiver Media Center installed successfully from local package"
|
|
else
|
|
err "JRiver Media Center local package installation failed"
|
|
return 1
|
|
fi
|
|
link_ssl_certs
|
|
# migrateLibrary
|
|
restore_license
|
|
open_firewall "jriver-mediacenter" "52100-52200/tcp" "1900/udp"
|
|
disable_btrfs_cow
|
|
fi
|
|
|
|
if (( CREATEREPO_SWITCH )); then
|
|
if run_createrepo; then
|
|
echo "Successfully updated repo"
|
|
else
|
|
err "Repo creation failed"
|
|
fi
|
|
fi
|
|
|
|
if [[ ${#SERVICES[@]} -gt 0 ]]; then
|
|
declare service
|
|
for service in "${SERVICES[@]}"; do
|
|
if ! "service_$service"; then
|
|
if [[ $? -eq 127 ]]; then
|
|
err "Service $service does not exist, check service name"
|
|
else
|
|
err "Failed to create $service service"
|
|
fi
|
|
else
|
|
echo "Started and enabled $service service"
|
|
fi
|
|
done
|
|
unset service
|
|
fi
|
|
|
|
# for _container in "${CONTAINERS[@]}"; do
|
|
# if ! "_container_$_container"; then
|
|
# if [[ $? -eq 127 ]]; then
|
|
# err "Container $_container does not exist, check container name"
|
|
# else
|
|
# err "Failed to create container: $_container"
|
|
# fi
|
|
# fi
|
|
# done
|
|
}
|
|
|
|
# Roughly turn debugging on, reparse in getInput() with getopt
|
|
[[ " $* " =~ ( --debug | -d ) ]] && declare -g DEBUG=1
|
|
|
|
main "$@"
|
|
|