github/plexupdate
1
0
Fork 0
mirror of https://github.com/mrworf/plexupdate.git synced 2025-08-19 21:03:19 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Installer script and cleanup

Browse source 
* Stop users from saving config with invalid download directory
* Added additional sanity for email checking
* Add installer script
* Update cronwrapper to work with installer script
* Add AUTOUPDATE to default config
* Read /etc/plexupdate.conf before other configs, if available
* Use dnf on newer redhat systems
* Only use plexupdate.conf or --config
* Give existing users explaination as to why plexupdate.sh failed
* Removed references to .plexupdate
* Warn users that .plexupdate is going away
* Offer to import settings in ~/.plexupdate.conf in installer (if they exist)
* Only show AUTOSTART warning if AUTOINSTALL is enabled
* Change default download directory to /tmp
* Warn users to run the installer as sudo
* Remove VAR_CL logic in favor of checking config before getopt run
* Use sha1sum for version check and auto-fix git permissions on exit
* Skip update check if AUTOUPDATE is enabled
* Fix permissions for all files, not just .git
* Don't enable -P in installer if we know it won't work
This commit is contained in:
Alex Malinovich 2016-12-09 10:53:40 -08:00 • committed by Henric Andersson
commit 88a759a79c
4 changed files with 614 additions and 275 deletions
Download patch file Download diff file Expand all files Collapse all files

158
README.md Executable file → Normal file
View file

@ -1,16 +1,38 @@
![plexupdate.sh](http://i.imgur.com/ThY5Rvl.png "plexupdate")
# plexupdate
Plex Update is a BASH script which simplifies the life of headless Linux Plex Media Server users (how's that for a strange description).
Plex Update is a bash script which helps you keep Plex Media Server up to date on Linux.
This tool will automatically download the latest version for linux (Using plexpass or public version) and if you **kindly ask**, also install it for you.
plexupdate will automatically download the latest version of Plex Media Server for Linux and, optionally, also install it for you.
### What happened to `.plexupdate` ?
It has gone away to keep things simpler and more secure. You can either provide the config you want using the `--config` parameter or place it in `/etc/plexupdate.conf`.
# Installation
It's fairly easy, but let's take it step by step (if it seems too much, skip to the end for a short version)
In the old days, this used to be a bit of a chore. But no more!
```
bash -c "$(wget -O - https://raw.githubusercontent.com/mrworf/plexupdate/master/extras/installer.sh)"
```
will automatically install the tool as well as any dependencies. This has been tested on Ubuntu, Fedora and CentOS but should, for the most part, work on any modern Linux distribution.
If you'd ever like to change your configuration, you can just re-run this from the extras folder inside your plexupdate directory. (`/opt/plexupdate/extras/installer.sh` by default)
If you have any trouble with the installer, or would just prefer to set plexupdate up manually, read on.
## 1. Getting the code
####Using git to clone (recommended)
```
git clone https://github.com/mrworf/plexupdate.git
```
Note that git is required (`sudo apt-get install git`)
This is the recommended way to install plexupdate. Using git allows you to know when a new version is available as well allowing plexupdate to keep itself up to date (with the AUTOUPDATE option).
####Using wget and unzip
Download it as a [zip file](https://github.com/mrworf/plexupdate/archive/master.zip) and unzip it on your server.
@ -19,33 +41,71 @@ wget https://github.com/mrworf/plexupdate/archive/master.zip && unzip master.zip
```
Note that unzip is required (`sudo apt-get install unzip`).
####Using git to clone (Recommended)
Using git is way easier and recommended, if you ask me.
```
git clone https://github.com/mrworf/plexupdate.git
```
Note that git is required (`sudo apt-get install git`)
The main benefit with git clone is that you can update to latest version very easily. If you want to use the auto update feature, you must be using a git clone.
## 2. Setting it up
To quickly setup plexupdate.sh, you should run it the first time like below:
In order to use `plexupdate.sh`, it's recommended you create a configuration file.
```
./plexupdate.sh --email='my.email@plex-server.com' --pass='my-secret-plex-password' --dldir='/a/folder/to/save/the/files/in' --saveconfig
sudo nano -w /etc/plexupdate.conf
```
Obviously you need to change these so they match your account information. And if you don't put anything as for the ```--dldir``` option, the tool will use the folder you're executing the script from. So take care.
In the newly opened editor, insert the following (and make *sure* to change email and password)
## 3. Advanced options
```
EMAIL='john.doe@void.com'
PASS='verySecretPassword'
DOWNLOADDIR='/tmp/'
```
You can point out a different file than ```.plexupdate``` by providing it as the argument to the ```--config``` option. Any options set by the config file can be overridden with command-line options.
This will make `plexupdate.sh` login and download the latest version and save it to /tmp/ folder.
If you don't have PlexPass, you can still use `plexupdate.sh`, just set `PUBLIC=yes` instead. The section above becomes
```
PUBLIC=yes
DOWNLOADDIR='/tmp/'
```
## 3. Cronjob
You might be more interested in running this on a regular basis. To accomplish this, we need to do the following. Locate the `extras` folder which was included with plexupdate. In this folder you'll find `cronwrapper`. You need to "symlink" this into `/etc/cron.daily/`. Symlink means we tell the system that there should be reference/link to the file included in plexupdate. By not copying, we will automatically get updates to the `cronwrapper` when we update plexupdate.
When doing the symlink, it's important to provide the complete path to the file in question, so you will need to edit the path to it in the following snippet. Also, we need to run as root, since only root is allowed to edit files under `/etc`.
```
sudo ln -s /home/john/plexupdate/extras/cronwrapper /etc/cron.daily/plexupdate
```
We also need to tell cronwrapper where to find plexupdate, again, this needs to be done as root for the same reasons as above.
```
sudo nano -w /etc/plexupdate.cron.conf
```
In the new file, we simply point out the location of `plexupdate.sh` and `plexupdate.conf`
```
SCRIPT=/home/john/plexupdate/plexupdate.sh
CONF=/home/john/plexupdate.conf
```
If you've installed it somewhere else and/or the path to the config is somewhere else, please *make sure* to write the correct paths.
Almost done. Final step is to make `plexupdate.sh` a bit smarter and have it install the newly downloaded version, so open the `plexupdate.conf` file you created previously and add the following:
```
AUTOINSTALL=yes
AUTODELETE=yes
```
This tells `plexupdate.sh` to install the file once downloaded and delete it when done, keeping your server nice and clean.
## 4. Advanced options
There are also a few additional options for the more enterprising user. Setting any of these to `yes` will enable the function.
- CHECKUPDATE
If set (and it is by default), it will compare your local copy with the one stored on github. If there is any difference, it will let you know. This is handy if you're not using ```git clone``` but want to be alerted to new versions.
If set (and it is by default), it will compare your local copy with the one stored on github. If there is any difference, it will let you know. This is handy if you're not using `git clone` but want to be alerted to new versions.
- PLEXSERVER
If set, and combined with AUTOINSTALL, the script will automatically check if the server is in-use and defer the update. Great for crontab users. PLEXSERVER should be set to the IP/DNS of your Plex Media Server, which typically is 127.0.0.1
- PLEXPORT
@ -57,7 +117,7 @@ There are also a few additional options for the more enterprising user. Setting
- AUTODELETE
Once successfully downloaded and installed, it will delete the package (want not, waste not? ;-))
- PUBLIC
The default behavior of plexupdate.sh is to download the PlexPass edition of Plex Media Center. Setting this option to `yes` will make it download the public version instead. If this is yes, then `EMAIL` and `PASS` is no longer needed.
The default behavior of plexupdate.sh is to download the PlexPass edition of Plex Media Server. Setting this option to `yes` will make it download the public version instead. If this is yes, then `EMAIL` and `PASS` is no longer needed.
- FORCE
Normally plexupdate.sh will avoid downloading a file it already has or if it's the same as the installed version. Using this option will force it to download again UNLESS the file already downloaded has the correct checksum. If you have AUTOINSTALL set, plexupdate.sh will then reinstall it.
- FORCEALL
@ -72,69 +132,43 @@ There are also a few additional options for the more enterprising user. Setting
Most of these options can be specified on the command-line as well, this is just a more convenient way of doing it if you're scripting it. Which brings us to...
### Using it from CRON
Generally, you copy the cronwrapper from the extras folder into the ```/etc/cron.weekly``` and edit the script to suite your needs. It will require you to create a configuration file (or at least, it's highly recommended). It also provides logging via syslog if needed. Should the script fail, it will print why and in most cases, this will result in an email to you.
[Also checkout the wiki for more details](https://github.com/mrworf/plexupdate/wiki/Ubuntu%3A-Run-plexupdate.sh-from-cron)
### Command Line Options
Several new command line options are available. They can be specified in any order.
Plexupdate comes with many command line options. For the most up-to-date list, I'd recommend you run plexupdate.sh with -h
- ```--config <path/to/config/file>```
But here are some of the more useful ones:
- `--config <path/to/config/file>`
Defines the location the script should look for the config file.
- ```--email <Plex.tv email>```
- `--email <Plex.tv email>`
Email to sign in to Plex.tv
- ```--pass <Plex.tv password>```
- `--pass <Plex.tv password>`
Password to sign in to Plex.tv
- ```--dldir <path/to/where/you/want/files/downloaded/to>```
- `--dldir <path/to/where/you/want/files/downloaded/to>`
This is the folder that the files will be downloaded to.
- ```--server <Plex server address>```
- `--server <Plex server address>`
This is the address that Plex Media Server is on. Setting this will enable a check to see if users are on the server prior to the software being updated.
- ```--port <Plex server port>```
- `--port <Plex server port>`
This is the port that Plex Media Server uses.
- ```--saveconfig```
Saves the configuration as it is currently. This will take whatever is in the config file, plus whatever is specified on the command line and will save the config file with that information. Any information in the config file that plexupdate.sh does not understand or use WILL BE LOST.
### Logs
The script now outputs everything to a file (by default `/tmp/plexupdate.log`). This log ***MAY*** contain passwords, so if you post it online, ***USE CAUTION***.
To change the default log file, you can specify a new location:
```FILE_STDOUTLOG="<new/path/to/log>" ./plexupdate.sh <options>```
# Running it
It's very simple, just execute the tool once configured. It will complain if you've forgotten to set it up. If you want to use the autoinstall (-a option or `AUTOINSTALL=YES` is set), you must run as root or use sudo when executing or plexupdate.sh will stop and give you an error.
Overall it tries to give you hints regarding why it isn't doing what you expected it to.
# Trivia
- "kaka" is Swedish for "cookie"
# TL;DR
Open a terminal or SSH on the server running Plex Media Center
## First install
```
git clone https://github.com/mrworf/plexupdate.git
sudo plexupdate/plexupdate.sh -p -a
```
## Updating Plex and the script
```
sudo plexupdate/plexupdate.sh -p -u -a
```
# FAQ
## What username and password are you talking about
## Where is `.plexupdate`
The username and password for http://plex.tv
See explanation in the top of this document.
## What email and password are you talking about
The email and password for http://plex.tv
## My password is rejected even though correct
If you use certain characters (such as `$`) in your password, bash will interpret that as a reference to a variable. To resolve this, enclose your password within single quotes (`'`) instead of the normal quotes (`"`).
i.e. `PASS="MyP4$$w0rD"` will not work, but changing to it to `PASS='MyP4$$w0rD'` will
If it's still not working, run `plexupdate.sh` with `-v` which prints out the email and password used to login which might help you understand what the problem is.

54
extras/cronwrapper
View file

@ -17,50 +17,54 @@
# Set CONFIGURED to true once you've setup the previous three
# options.
#
CONFIGURED=false
CONF=
SCRIPT=/home/john.doe/plexupdate/plexupdate.sh
LOGGING=true
if ! $CONFIGURED; then
echo "ERROR: You have not configured this script" >&2
exit 255
if [ ! -f /etc/plexupdate.cron.conf ]; then
echo "ERROR: You have not configured /etc/plexupdate.cron.conf" >&2
exit 255
else
source /etc/plexupdate.cron.conf
fi
if [ -z "${SCRIPT}" -o ! -f "${SCRIPT}" ]; then
echo "ERROR: Cannot find plexupdate.sh (tried ${SCRIPT})" >&2
exit 255
echo "ERROR: Cannot find plexupdate.sh (tried ${SCRIPT})" >&2
exit 255
elif [ ${EUID} -eq 0 ]; then
UNSAFE_FILES=$(find -L "$(dirname "${SCRIPT}")" -perm /002 -or -not -uid 0 -or -not -gid 0)
if [ ! -z "${UNSAFE_FILES}" ]; then
echo "ERROR: Permissions on some files are too lax for running as root. Files must be owned by root:root and not world-writeable." >&2
echo "Unsafe files found:" >&2
echo "${UNSAFE_FILES}" >&2
exit 255
fi
fi
if [ ! -z "$CONF" ]; then
# We have a config file, prefix it with parameter
if [ ! -f "${CONF}" ]; then
echo "ERROR: Cannot find config file (tried ${CONF})" >&2
exit 255
fi
CONF="--config=${CONF}"
# We have a config file, prefix it with parameter
if [ ! -f "${CONF}" ]; then
echo "ERROR: Cannot find config file (tried ${CONF})" >&2
exit 255
fi
CONF="--config=${CONF}"
fi
LOGFILE=$(mktemp /tmp/plexupdate.cron.XXXX)
RET=0
if $LOGGING; then
"${SCRIPT}" "${CONF}" 2>&1 | tee ${LOGFILE} | logger -t plexupdate -p daemon.info
if grep -q '^ERROR:' ${LOGFILE}; then
RET=1
fi
"${SCRIPT}" "${CONF}" 2>&1 | tee ${LOGFILE} | logger -t plexupdate -p daemon.info
RET="${PIPESTATUS[0]}"
else
"${SCRIPT}" "${CONF}" >${LOGFILE} 2>&1
RET=$?
"${SCRIPT}" "${CONF}" >${LOGFILE} 2>&1
RET=$?
fi
if [ $RET -ne 2 -a $RET -ne 5 ]; then
# Make sure user gets an email about this
cat ${LOGFILE} >&2
# Make sure user gets an email about this
cat ${LOGFILE} >&2
else
# Nah, not important
RET=0
# Nah, not important
RET=0
fi
rm "${LOGFILE}" 2>/dev/null

346
extras/installer.sh Executable file
View file

@ -0,0 +1,346 @@
#!/bin/bash
ORIGIN_REPO="https://github.com/mrworf/plexupdate"
FULL_PATH="/opt/plexupdate"
CONFIGFILE="/etc/plexupdate.conf"
CONFIGCRON="/etc/plexupdate.cron.conf"
CRONWRAPPER="/etc/cron.daily/plexupdate"
# default options
AUTOINSTALL=yes
AUTOUPDATE=yes
PUBLIC=
install() {
echo "'$req' is required but not installed, attempting to install..."
sleep 1
[ -z "$DISTRO_INSTALL" ] && check_distro
if [ $EUID -ne 0 ]; then
sudo $DISTRO_INSTALL $1 || abort "Failed while trying to install '$1'. Please install it manually and try again."
fi
}
check_distro() {
if [ -f /etc/redhat-release ] && hash dnf 2>/dev/null; then
DISTRO="redhat"
DISTRO_INSTALL="dnf -y install"
elif [ -f /etc/redhat-release ] && hash yum 2>/dev/null; then
DISTRO="redhat" #or CentOS but functionally the same
DISTRO_INSTALL="yum -y install"
elif hash apt 2>/dev/null; then
DISTRO="debian" #or Ubuntu
DISTRO_INSTALL="apt install"
elif hash apt-get 2>/dev/null; then
DISTRO="debian"
DISTRO_INSTALL="apt-get install"
else
DISTRO="unknown"
fi
}
yesno() {
case "$1" in
"")
default="Y"
;;
yes)
default="Y"
;;
true)
default="Y"
;;
no)
default="N"
;;
false)
default="N"
;;
*)
default="$1"
;;
esac
default="$(tr "[:lower:]" "[:upper:]" <<< "$default")"
if [ "$default" == "Y" ]; then
prompt="[Y/n] "
else
prompt="[N/y] "
fi
while true; do
read -n 1 -p "$prompt" answer
answer=${answer:-$default}
answer="$(tr "[:lower:]" "[:upper:]" <<< "$answer")"
if [ "$answer" == "Y" ]; then
echo
return 0
elif [ "$answer" == "N" ]; then
echo
return 1
fi
done
}
noyes() {
yesno N
}
abort() {
echo "$@"
exit 1
}
install_plexupdate() {
echo
read -e -p "Directory to install into: " -i "/opt/plexupdate" FULL_PATH
while [[ "$FULL_PATH" == *"~"* ]]; do
echo "Using '~' in your path can cause problems, please type out the full path instead"
echo
read -e -p "Directory to install into: " -i "/opt/plexupdate" FULL_PATH
done
if [ ! -d "$FULL_PATH" ]; then
echo -n "'$FULL_PATH' doesn't exist, attempting to create... "
if ! mkdir -p "$FULL_PATH" 2>/dev/null; then
sudo mkdir -p "$FULL_PATH" || abort "failed, cannot continue"
sudo chown $(id -un):$(id -gn) "$FULL_PATH" || abort "failed, cannot continue"
fi
echo "done"
elif [ ! -w "$FULL_PATH" ]; then
echo -n "'$FULL_PATH' exists, but you don't have permission to write to it. Changing owner... "
sudo chown $(id -un):$(id -gn) "$FULL_PATH" || abort "failed, cannot continue"
echo "done"
fi
if [ -d "${FULL_PATH}/.git" ]; then
cd "$FULL_PATH"
if git remote -v 2>/dev/null | grep -q "plexupdate"; then
echo -n "Found existing plexupdate repository in '$FULL_PATH', updating... "
git pull &>/dev/null || abort "Unknown error while updating, please check '$FULL_PATH' and then try again."
else
abort "'$FULL_PATH' appears to contain a different git repository, cannot continue"
fi
echo "done"
cd - &> /dev/null
else
echo -n "Installing plexupdate into '$FULL_PATH'... "
git clone "$ORIGIN_REPO" "$FULL_PATH" &> /dev/null || abort "install failed, cannot continue"
echo "done"
fi
}
configure_plexupdate() {
[ -f "$CONFIGFILE" ] && source "$CONFIGFILE"
echo
echo -n "Do you want to install the latest PlexPass releases? (requires PlexPass username and password) "
# The answer to this question and the value of PUBLIC are basically inverted
if [ "$PUBLIC" == "yes" ]; then
default=N
fi
if yesno $default; then
PUBLIC=no
while true; do
read -e -p "PlexPass Email Address: " -i "$EMAIL" EMAIL
if [ -z "${EMAIL}" ] || [[ "$EMAIL" == *"@"* ]] && [[ "$EMAIL" != *"@"*"."* ]]; then
echo "Please provide a valid email address"
else
break
fi
done
while true; do
read -e -p "PlexPass Password: " -i "$PASS" PASS
if [ -z "$PASS" ]; then
echo "Please provide a password"
else
break
fi
done
else
# don't forget to erase old settings if they changed their answer
EMAIL=
PASS=
PUBLIC=yes
fi
echo
echo -n "Would you like to automatically install the latest release when it is downloaded? "
if yesno "$AUTOINSTALL"; then
AUTOINSTALL=yes
[ -z "$DISTRO" ] && check_distro
if [ "$DISTRO" == "redhat" ]; then
AUTOSTART=yes
else
AUTOSTART=
fi
echo
echo -n "When using the auto-install option, would you like to check if the server is in use before upgrading? "
#We can't tell if they previously selected no or if this is their first run, so we have to assume Yes
if yesno; then
if [ -z "$PLEXSERVER" ]; then
PLEXSERVER="127.0.0.1"
fi
while true; do
read -e -p "Plex Server IP/DNS name: " -i "$PLEXSERVER" PLEXSERVER
if ! ping -c 1 -w 1 "$PLEXSERVER" &>/dev/null ; then
echo -n "Server $PLEXSERVER isn't responding, are you sure you entered it correctly? "
if yesno N; then
break
fi
else
break
fi
done
if [ -z "$PLEXPORT" ]; then
PLEXPORT=32400
fi
while true; do
read -e -p "Plex Server Port: " -i "$PLEXPORT" PLEXPORT
if ! [[ "$PLEXPORT" =~ ^[1-9][0-9]*$ ]]; then
echo "Port $PLEXPORT isn't valid, please try again"
PLEXPORT=32400
else
break
fi
done
else
PLEXSERVER=
PLEXPORT=
fi
else
AUTOINSTALL=no
PLEXSERVER=
PLEXPORT=
fi
save_config "AUTOINSTALL AUTODELETE DOWNLOADDIR EMAIL PASS FORCE FORCEALL PUBLIC AUTOSTART AUTOUPDATE PLEXSERVER PLEXPORT CHECKUPDATE" "$CONFIGFILE"
}
configure_cron() {
if [ ! -d "$(dirname "$CRONWRAPPER")" ]; then
echo "It seems like you don't have a supported cron job setup, please see README.md for more details."
return 1
fi
[ -f "$CONFIGCRON" ] && source "$CONFIGCRON"
echo
echo -n "Would you like to set up automatic daily updates for Plex? "
if yesno $CRON; then
if [ $(sudo find -L "${FULL_PATH}" -perm /002 -or -not -uid 0 -or -not -gid 0 | wc -l) -ne 0 ]; then
echo
echo "WARNING: For security reasons, plexupdate needs to be installed as root in order to run automatically. In order to finish setting up automatic updates, we will change the ownership of '${FULL_PATH}' to root:root."
echo -n "Do you wish to continue? "
yesno || return 1
echo
echo -n "Changing ownership of '${FULL_PATH}'... "
sudo chown -R root:root "${FULL_PATH}" || abort "Unable to change ownership, cannot continue"
sudo chmod -R o-w "${FULL_PATH}" || abort "Unable to change permissions, cannot continue"
echo "done"
fi
CONF="$CONFIGFILE"
SCRIPT="${FULL_PATH}/plexupdate.sh"
LOGGING=${LOGGING:-false}
echo
echo -n "Do you want to log the daily update runs to syslog so you can examine the output later? "
if yesno $LOGGING; then
LOGGING=true
fi
save_config "CONF SCRIPT LOGGING" "/etc/plexupdate.cron.conf"
echo
echo -n "Installing daily cron job... "
sudo ln -sf "${FULL_PATH}/extras/cronwrapper" "$CRONWRAPPER"
echo "done"
elif [ -f "$CRONWRAPPER" -o -f "$CONFIGCRON" ]; then
echo
echo -n "Cleaning up old cron configuration... "
if [ -f "$CRONWRAPPER" ]; then
sudo rm "$CRONWRAPPER" || echo "Failed to remove old cron script, please check '$CRONWRAPPER'"
fi
if [ -f "$CONFIGCRON" ]; then
sudo rm "$CONFIGCRON" || echo "Failed to remove old cron configuration, please check '$CONFIGCRON'"
fi
echo done
fi
}
save_config() {
CONFIGTEMP=$(mktemp /tmp/plexupdate.XXX)
for VAR in $1; do
if [ ! -z "${!VAR}" ]; then
echo "${VAR}='${!VAR}'" >> $CONFIGTEMP
fi
done
echo
echo -n "Writing configuration file '$2'... "
# make sure that new file is owned by root instead of owner of CONFIGTEMP
sudo tee "$2" > /dev/null < "$CONFIGTEMP"
rm "$CONFIGTEMP"
echo "done"
}
if [ $EUID -ne 0 ]; then
echo
echo "This script needs to install files in system locations and will ask for sudo/root permissions now"
sudo -v || abort "Root permissions are required for setup, cannot continue"
elif [ ! -z "$SUDO_USER" ]; then
echo
abort "This script will ask for sudo as necessary, but you should not run it as sudo. Please try again."
fi
for req in wget git; do
if ! hash $req 2>/dev/null; then
install $req
fi
done
if [ -f ~/.plexupdate ]; then
echo
echo -n "Existing configuration found in ~/.plexupdate, would you like to import these settings? "
if yesno; then
echo "Backing up old configuration as ~/.plexupdate.old. All new settings should be modified through this script, or by editing ${CONFIGFILE} directly. Please see README.md for more details."
source ~/.plexupdate
mv ~/.plexupdate ~/.plexupdate.old
fi
fi
if [ -f "$(dirname "$0")/../plexupdate.sh" -a -d "$(dirname "$0")/../.git" ]; then
FULL_PATH="$(readlink -f "$(dirname "$0")/../")"
echo
echo "Found plexupdate.sh in '$FULL_PATH', using that as your install path"
else
install_plexupdate
fi
configure_plexupdate
configure_cron
echo
echo -n "Configuration complete. Would you like to run plexupdate with these settings now? "
if yesno; then
if wget --show-progress -V &> /dev/null; then
PROGRESS_OPT="-P"
fi
if [ "$AUTOINSTALL" == "yes" ]; then
sudo "$FULL_PATH/plexupdate.sh" $PROGRESS_OPT --config "$CONFIGFILE"
else
"$FULL_PATH/plexupdate.sh" $PROGRESS_OPT --config "$CONFIGFILE"
fi
fi

331
plexupdate.sh
View file

@ -7,13 +7,16 @@
# as well as the PlexPass versions.
#
# PlexPass users:
# Create a separate .plexupdate file in your home directory with these
# Create a plexupdate.conf file in your home directory with these
# values:
#
# EMAIL='<whatever your plexpass email was>'
# PASS='<whatever password you used>'
# DOWNLOADDIR='<where you would like to save the downloaded package>'
#
# And run the tool using: ./plexupdate.sh --config plexupdate.conf
# or place the config in /etc/plexupdate.conf
#
# See https://github.com/mrworf/plexupdate for more details.
#
# Returns 0 on success
@ -33,21 +36,21 @@
# Check out https://github.com/mrworf/plexupdate for latest version
# and also what's new.
#
####################################################################
##############################################################################
# Quick-check before we allow bad things to happen
if [ -z "${BASH_VERSINFO}" ]; then
echo "ERROR: You must execute this script with BASH" >&2
exit 255
fi
#################################################################
# Don't change anything below this point, use a .plexupdate file
# in your home directory to override this section.
##############################################################################
# Don't change anything below this point, use a plexupdate.conf file
# to override this section.
# DOWNLOADDIR is the full directory path you would like the download to go.
#
EMAIL=
PASS=
DOWNLOADDIR="."
DOWNLOADDIR="/tmp"
PLEXSERVER=
PLEXPORT=32400
@ -61,13 +64,12 @@ AUTODELETE=no
AUTOUPDATE=no
AUTOSTART=no
ARCH=$(uname -m)
IGNOREAUTOUPDATE=no
SHOWPROGRESS=no
WGETOPTIONS="" # extra options for wget. Used for progress bar.
CHECKUPDATE=yes
# Default options for package managers, override if needed
REDHAT_INSTALL="yum -y install"
REDHAT_INSTALL="dnf -y install"
DEBIAN_INSTALL="dpkg -i"
DISTRO_INSTALL=""
@ -76,6 +78,15 @@ URL_LOGIN='https://plex.tv/users/sign_in.json'
URL_DOWNLOAD='https://plex.tv/api/downloads/1.json?channel=plexpass'
URL_DOWNLOAD_PUBLIC='https://plex.tv/api/downloads/1.json'
#URL for new version check
UPSTREAM_GIT_URL='https://raw.githubusercontent.com/mrworf/plexupdate/master/plexupdate.sh'
#Branch to fetch updates from
BRANCHNAME="master"
#Files "owned" by plexupdate, for autoupdate
PLEXUPDATE_FILES="plexupdate.sh extras/installer.sh extras/cronwrapper"
FILE_POSTDATA=$(mktemp /tmp/plexupdate.postdata.XXXX)
FILE_RAW=$(mktemp /tmp/plexupdate.raw.XXXX)
FILE_FAILCAUSE=$(mktemp /tmp/plexupdate.failcause.XXXX)
@ -115,8 +126,9 @@ usage() {
echo " -P Show progressbar when downloading big files"
echo " -r Print download URL and exit"
echo " -s Auto start (needed for some distros)"
echo " -u Auto update plexupdate.sh before running it (experimental)"
echo " -U Do not autoupdate plexupdate.sh (experimental, default)"
echo " -u Auto update plexupdate.sh before running it (default with installer)"
echo " -U Do not autoupdate plexupdate.sh"
echo " -v Show additional debug information"
echo ""
echo " Long Argument Options:"
echo " --config <path/to/config/file> Configuration file to use"
@ -125,7 +137,6 @@ usage() {
echo " --pass <plex.tv password> Plex.TV password"
echo " --server <Plex server address> Address of Plex Server"
echo " --port <Plex server port> Port for Plex Server. Used with --server"
echo " --saveconfig Save the configuration to config file"
echo
exit 0
}
@ -198,55 +209,66 @@ cleanup() {
}
trap cleanup EXIT
if [ ! $# -eq 0 ]; then
HASCFG="${@: -1}"
if [ ! -z "${HASCFG}" -a ! "${HASCFG:0:1}" = "-" -a ! "${@:(-2):1}" = "--config" ]; then
if [ -f "${HASCFG}" ]; then
warn "Specifying config file as last argument is deprecated. Use --config <path> instead."
CONFIGFILE=${HASCFG}
fi
fi
fi
# Parse commandline
ALLARGS=( "$@" )
optstring="acCdfFhlpPqrSsuU -l config:,dldir:,email:,pass:,server:,port:,saveconfig"
getopt -T >/dev/null
if [ $? -eq 4 ]; then
optstring="-o $optstring"
fi
optstring="-o acCdfFhlpPqrSsuUv -l config:,dldir:,email:,pass:,server:,port:"
GETOPTRES=$(getopt $optstring -- "$@")
if [ $? -eq 1 ]; then
exit 1
fi
set -- ${GETOPTRES}
for i in `seq 1 $#`; do
if [ "${!i}" == "--config" ]; then
config_index=$((++i))
CONFIGFILE=$(trimQuotes ${!config_index})
break
fi
done
#DEPRECATED SUPPORT: Temporary error checking to notify people of change from .plexupdate to plexupdate.conf
# We have to double-check that both files exist before trying to stat them. This is going away soon.
if [ -z "${CONFIGFILE}" -a -f ~/.plexupdate -a ! -f /etc/plexupdate.conf ] || \
([ -f "${CONFIGFILE}" -a -f ~/.plexupdate ] && [ `stat -Lc %i "${CONFIGFILE}"` == `stat -Lc %i ~/.plexupdate` ]); then
warn ".plexupdate has been deprecated. You should move your configuration to /etc/plexupdate.conf"
if [ -t 1 ]; then
for i in `seq 1 5`; do echo -n .\ ; sleep 1; done
echo .
fi
CONFIGFILE=~/.plexupdate
fi
#DEPRECATED END
# If a config file was specified, or if /etc/plexupdate.conf exists, we'll use it. Otherwise, just skip it.
source "${CONFIGFILE:-"/etc/plexupdate.conf"}" 2>/dev/null
while true;
do
case "$1" in
(-h) usage;;
(-a) AUTOINSTALL_CL=yes;;
(-a) AUTOINSTALL=yes;;
(-c) error "CRON option is deprecated, please use cronwrapper (see README.md)"; exit 255;;
(-C) error "CRON option is deprecated, please use cronwrapper (see README.md)"; exit 255;;
(-d) AUTODELETE_CL=yes;;
(-f) FORCE_CL=yes;;
(-F) FORCEALL_CL=yes;;
(-d) AUTODELETE=yes;;
(-f) FORCE=yes;;
(-F) FORCEALL=yes;;
(-l) LISTOPTS=yes;;
(-p) PUBLIC_CL=yes;;
(-p) PUBLIC=yes;;
(-P) SHOWPROGRESS=yes;;
(-q) error "QUIET option is deprecated, please redirect to /dev/null instead"; exit 255;;
(-r) PRINT_URL=yes;;
(-s) AUTOSTART_CL=yes;;
(-u) AUTOUPDATE_CL=yes;;
(-U) IGNOREAUTOUPDATE=yes;;
(-s) AUTOSTART=yes;;
(-u) AUTOUPDATE=yes;;
(-U) AUTOUPDATE=no;;
(-v) VERBOSE=yes;;
(--config) shift; CONFIGFILE="$1"; CONFIGFILE=$(trimQuotes ${CONFIGFILE});;
(--dldir) shift; DOWNLOADDIR_CL="$1"; DOWNLOADDIR_CL=$(trimQuotes ${DOWNLOADDIR_CL});;
(--email) shift; EMAIL_CL="$1"; EMAIL_CL=$(trimQuotes ${EMAIL_CL});;
(--pass) shift; PASS_CL="$1"; PASS_CL=$(trimQuotes ${PASS_CL});;
(--server) shift; PLEXSERVER_CL="$1"; PLEXSERVER_CL=$(trimQuotes ${PLEXSERVER_CL});;
(--port) shift; PLEXPORT_CL="$1"; PLEXPORT_CL=$(trimQuotes ${PLEXPORT_CL});;
(--saveconfig) SAVECONFIG=yes;;
(--config) shift;; #gobble up the paramater and silently continue parsing
(--dldir) shift; DOWNLOADDIR=$(trimQuotes ${1});;
(--email) shift; EMAIL=$(trimQuotes ${1});;
(--pass) shift; PASS=$(trimQuotes ${1});;
(--server) shift; PLEXSERVER=$(trimQuotes ${1});;
(--port) shift; PLEXPORT=$(trimQuotes ${1});;
(--) ;;
(-*) error "Unrecognized option $1"; usage; exit 1;;
@ -261,108 +283,12 @@ if ! hash wget 2>/dev/null; then
exit 1
fi
# Allow manual control of configfile
if [ ! -z "${CONFIGFILE}" ]; then
if [ -f "${CONFIGFILE}" ]; then
info "Using configuration: ${CONFIGFILE}" #>/dev/null
source "${CONFIGFILE}"
else
error "Cannot load configuration ${CONFIGFILE}"
exit 1
fi
else
# Load settings from config file if it exists
# Also, respect SUDO_USER and try that first
if [ ! -z "${SUDO_USER}" ]; then
# Make sure nothing bad comes from this (since we use eval)
ERROR=0
if [[ $SUDO_USER == *";"* ]]; then ERROR=1 ; # Allows more commands
elif [[ $SUDO_USER == *" "* ]]; then ERROR=1 ; # Space is not a good thing
elif [[ $SUDO_USER == *"&"* ]]; then ERROR=1 ; # Spinning off the command is bad
elif [[ $SUDO_USER == *"<"* ]]; then ERROR=1 ; # No redirection
elif [[ $SUDO_USER == *">"* ]]; then ERROR=1 ; # No redirection
elif [[ $SUDO_USER == *"|"* ]]; then ERROR=1 ; # No pipes
elif [[ $SUDO_USER == *"~"* ]]; then ERROR=1 ; # No tilde
fi
if [ ${ERROR} -gt 0 ]; then
error "SUDO_USER variable is COMPROMISED: \"${SUDO_USER}\""
exit 255
fi
# Try using original user's config
CONFIGDIR="$( eval cd ~${SUDO_USER} 2>/dev/null && pwd )"
if [ -z "${CONFIGDIR}" ]; then
warn "SUDO_USER \"${SUDO_USER}\" does not have a valid home directory, ignoring."
fi
if [ ! -z "${CONFIGDIR}" -a -f "${CONFIGDIR}/.plexupdate" ]; then
info "Using \"${SUDO_USER}\" configuration: ${CONFIGDIR}/.plexupdate" #>/dev/null
CONFIGFILE="${CONFIGDIR}/.plexupdate"
source "${CONFIGDIR}/.plexupdate"
elif [ -f ~/.plexupdate ]; then
# Fallback for compatibility
info "Using \"${SUDO_USER}\" configuration: ${HOME}/.plexupdate" #>/dev/null
CONFIGFILE="${HOME}/.plexupdate" # tilde expansion won't happen later.
source ~/.plexupdate
fi
elif [ -f ~/.plexupdate ]; then
# Fallback for compatibility
info "Using configuration: ${HOME}/.plexupdate" #>/dev/null
CONFIGFILE="${HOME}/.plexupdate"
source ~/.plexupdate
fi
fi
# The way I wrote this, it assumes that whatever we put on the command line is what we want and should override
# any values in the configuration file. As a result, we need to check if they've been set on the command line
# and overwrite the values that may have been loaded with the config file
for VAR in AUTOINSTALL AUTODELETE DOWNLOADDIR EMAIL PASS FORCE FORCEALL PUBLIC AUTOSTART AUTOUPDATE PLEXSERVER PLEXPORT
do
VAR2="$VAR""_CL"
if [ ! -z ${!VAR2} ]; then
eval $VAR='${!VAR2}'
fi
done
# This will destroy and recreate the config file. Any settings that are set in the config file but are no longer
# valid will NOT be saved.
if [ "${SAVECONFIG}" = "yes" ]; then
echo "# Config file for plexupdate" >${CONFIGFILE:="${HOME}/.plexupdate"}
for VAR in AUTOINSTALL AUTODELETE DOWNLOADDIR EMAIL PASS FORCE FORCEALL PUBLIC AUTOSTART AUTOUPDATE PLEXSERVER PLEXPORT CHECKUPDATE
do
if [ ! -z ${!VAR} ]; then
# The following keys have defaults set in this file. We don't want to include these values if they are the default.
if [ ${VAR} = "FORCE" \
-o ${VAR} = "FORCEALL" \
-o ${VAR} = "PUBLIC" \
-o ${VAR} = "AUTOINSTALL" \
-o ${VAR} = "AUTODELETE" \
-o ${VAR} = "AUTOUPDATE" \
-o ${VAR} = "AUTOSTART" ]; then
if [ ${!VAR} = "yes" ]; then
echo "${VAR}='${!VAR}'" >> ${CONFIGFILE}
fi
elif [ ${VAR} = "PLEXPORT" ]; then
if [ ! "${!VAR}" = "32400" ]; then
echo "${VAR}='${!VAR}'" >> ${CONFIGFILE}
fi
else
echo "${VAR}='${!VAR}'" >> ${CONFIGFILE}
fi
fi
done
fi
if [ "${SHOWPROGRESS}" = "yes" ]; then
WGETOPTIONS="--show-progress"
fi
if [ "${IGNOREAUTOUPDATE}" = "yes" ]; then
AUTOUPDATE=no
if ! wget --show-progress -V &>/dev/null; then
warn "Your wget is too old to support --show-progress, ignoring"
else
WGETOPTIONS="--show-progress"
fi
fi
if [ "${CRON}" = "yes" ]; then
@ -371,12 +297,12 @@ if [ "${CRON}" = "yes" ]; then
fi
if [ "${KEEP}" = "yes" ]; then
error "KEEP is deprecated and should be removed from .plexupdate"
error "KEEP is deprecated and should be removed from config file"
exit 255
fi
if [ ! -z "${RELEASE}" ]; then
error "RELEASE keyword is deprecated and should be removed from .plexupdate"
error "RELEASE keyword is deprecated and should be removed from config file"
error "Use DISTRO and BUILD instead to manually select what to install (check README.md)"
exit 255
fi
@ -386,50 +312,78 @@ if [ "${AUTOUPDATE}" = "yes" ]; then
error "You need to have git installed for this to work"
exit 1
fi
pushd "$(dirname "$0")" >/dev/null
if [ ! -d .git ]; then
error "This is not a git repository, auto update only works if you've done a git clone"
exit 1
fi
git status | grep "git commit -a" >/dev/null 2>/dev/null
if [ $? -eq 0 ]; then
error "You have made changes to the script, cannot auto update"
exit 1
fi
info "Auto updating"
git pull >/dev/null
if [ $? -ne 0 ]; then
error 'Unable to update git, try running "git pull" manually to see what is wrong'
exit 1
fi
info "Update complete"
popd >/dev/null
if ! type "$0" 2>/dev/null >/dev/null ; then
if [ -f "$0" ]; then
/bin/bash "$0" -U ${ALLARGS[@]}
else
error "Unable to relaunch, couldn't find $0"
pushd "$(dirname "$0")" >/dev/null
if [ ! -d .git ]; then
error "This is not a git repository. Auto-update only works if you've done a git clone"
exit 1
fi
if ! git diff --quiet; then
error "You have made changes to the plexupdate files, cannot auto update"
exit 1
fi
# Force FETCH_HEAD to point to the correct branch (for older versions of git which don't default to current branch)
if git fetch origin $BRANCHNAME --quiet && ! git diff --quiet FETCH_HEAD; then
info "Auto-updating..."
# Use an associative array to store permissions. If you're running bash < 4, the declare will fail and we'll
# just run in "dumb" mode without trying to restore permissions
declare -A FILE_OWNER FILE_PERMS && \
for filename in $PLEXUPDATE_FILES; do
FILE_OWNER[$filename]=$(stat -c "%u:%g" "$filename")
FILE_PERMS[$filename]=$(stat -c "%a" "$filename")
done
if ! git merge --quiet FETCH_HEAD; then
error 'Unable to update git, try running "git pull" manually to see what is wrong'
exit 1
fi
else
"$0" -U ${ALLARGS[@]}
if [ ${#FILE_OWNER[@]} -gt 0 ]; then
for filename in $PLEXUPDATE_FILES; do
chown ${FILE_OWNER[$filename]} $filename &> /dev/null || error "Failed to restore ownership for '$filename' after auto-update"
chmod ${FILE_PERMS[$filename]} $filename &> /dev/null || error "Failed to restore permissions for '$filename' after auto-update"
done
fi
# .git permissions don't seem to be affected by running as root even though files inside do, so just reset
# the permissions to match the folder
chown -R --reference=.git .git
info "Update complete"
#make sure we're back in the right relative location before testing $0
popd >/dev/null
if [ ! -f "$0" ]; then
error "Unable to relaunch, couldn't find $0"
exit 1
else
[ -x "$0" ] || chmod 755 "$0"
"$0" ${ALLARGS[@]}
exit $?
fi
fi
exit $?
#we may have already returned, so ignore any errors as well
popd &>/dev/null
fi
# Sanity check
if [ -z "${EMAIL}" -o -z "${PASS}" ] && [ "${PUBLIC}" = "no" ]; then
error "Need username & password to download PlexPass version. Otherwise run with -p to download public version."
exit 1
elif [ ! -z "${EMAIL}" ] && [[ "$EMAIL" == *"@"* ]] && [[ "$EMAIL" != *"@"*"."* ]]; then
error "EMAIL field must contain a valid email address"
exit 1
fi
if [ "${AUTOINSTALL}" = "yes" -o "${AUTOSTART}" = "yes" ]; then
id | grep -i 'uid=0(' 2>&1 >/dev/null
if [ $? -ne 0 ]; then
error "You need to be root to use AUTOINSTALL/AUTOSTART option."
exit 1
fi
if [ "${AUTOINSTALL}" = "yes" -o "${AUTOSTART}" = "yes" ] && [ ${EUID} -ne 0 ]; then
error "You need to be root to use AUTOINSTALL/AUTOSTART option."
fi
@ -448,7 +402,11 @@ if [ -z "${DISTRO_INSTALL}" ]; then
REDHAT=yes
BUILD="linux-ubuntu-${ARCH}"
DISTRO="redhat"
DISTRO_INSTALL="${REDHAT_INSTALL}"
if ! hash dnf 2>/dev/null; then
DISTRO_INSTALL="${REDHAT_INSTALL/dnf/yum}"
else
DISTRO_INSTALL="${REDHAT_INSTALL}"
fi
else
REDHAT=no
BUILD="linux-ubuntu-${ARCH}"
@ -466,10 +424,10 @@ else
fi
fi
if [ "${CHECKUPDATE}" = "yes" ]; then
(wget -q https://raw.githubusercontent.com/mrworf/plexupdate/master/plexupdate.sh -O - 2>/dev/null || echo ERROR) | shasum >"${FILE_REMOTE}" 2>/dev/null
if [ "${CHECKUPDATE}" = "yes" -a "${AUTOUPDATE}" = "no" ]; then
(wget -q "$UPSTREAM_GIT_URL" -O - 2>/dev/null || echo ERROR) | sha1sum >"${FILE_REMOTE}" 2>/dev/null
ERR1=$?
(cat "$0" 2>/dev/null || echo ERROR) | shasum >"${FILE_LOCAL}" 2>/dev/null
(cat "$0" 2>/dev/null || echo ERROR) | sha1sum >"${FILE_LOCAL}" 2>/dev/null
ERR2=$?
if [ $ERR1 -ne 0 -o $ERR2 -ne 0 ]; then
error "When checking for version, was unable to confirm version of script"
@ -519,6 +477,9 @@ if [ "${PUBLIC}" = "no" ]; then
RESULTCODE=$(head -n1 "${FILE_RAW}" | grep -oe '[1-5][0-9][0-9]')
if [ $RESULTCODE -eq 401 ]; then
error "Username and/or password incorrect"
if [ "$VERBOSE" = "yes" ]; then
info "Tried using \"${EMAIL}\" and \"${PASS}\" "
fi
exit 1
elif [ $RESULTCODE -ne 201 ]; then
error "Failed to login, debug information:"
@ -590,11 +551,11 @@ fi
# By default, try downloading
SKIP_DOWNLOAD="no"
# Installed version detection (only supported for deb based systems, feel free to submit rpm equivalent)
# Installed version detection
if [ "${REDHAT}" != "yes" ]; then
INSTALLED_VERSION=$(dpkg-query -s plexmediaserver 2>/dev/null | grep -Po 'Version: \K.*')
else
if [ "${AUTOSTART}" = "no" ]; then
if [ "${AUTOINSTALL}" = "yes" -a "${AUTOSTART}" = "no" ]; then
warn "Your distribution may require the use of the AUTOSTART [-s] option for the service to start after the upgrade completes."
fi
INSTALLED_VERSION=$(rpm -qv plexmediaserver 2>/dev/null)
@ -638,12 +599,6 @@ if [ "${SKIP_DOWNLOAD}" = "no" ]; then
info "Downloading release \"${FILENAME}\""
wget ${WGETOPTIONS} -o "${FILE_WGETLOG}" --load-cookies "${FILE_KAKA}" --save-cookies "${FILE_KAKA}" --keep-session-cookies "${DOWNLOAD}" -O "${DOWNLOADDIR}/${FILENAME}" 2>&1
CODE=$?
if [ ${CODE} -eq 2 ]; then
error "Your wget is too old to support --show-progress"
info "Trying to download release \"${FILENAME}\" again"
wget -o "${FILE_WGETLOG}" --load-cookies "${FILE_KAKA}" --save-cookies "${FILE_KAKA}" --keep-session-cookies "${DOWNLOAD}" -O "${DOWNLOADDIR}/${FILENAME}" 2>&1
CODE=$?
fi
if [ ${CODE} -ne 0 ]; then
error "Download failed with code ${CODE}:"