weewx/pkg/debian/postinst

#!/bin/sh
# postinst script for weewx debian package
# Copyright 2013-2024 Matthew Wall
#
# ways this script might be invoked:
#
# postinst configure most-recently-configured-version
# old-postinst abort-upgrade new-version
# conflictor's-postinst abort-remove in-favour package new-version
# postinst abort-remove
# deconfigured's-postinst abort-deconfigure in-favour failed-install-package
#   version [removing conflicting-package version]

# abort if any command returns error
set -e

# get debconf stuff so we can set configuration defaults
. /usr/share/debconf/confmodule

cfgfile=/etc/weewx/weewx.conf
cfgapp=/usr/bin/weectl
ts=`date +"%Y%m%d%H%M%S"`

WEEWX_USER="${WEEWX_USER:-weewx}"
WEEWX_GROUP="${WEEWX_GROUP:-weewx}"
WEEWX_HOME="${WEEWX_HOME:-/var/lib/weewx}"
WEEWX_HTMLDIR="${WEEWX_HTMLDIR:-/var/www/html/weewx}"
WEEWX_USERDIR=/etc/weewx/bin/user

# insert the driver and stanza into the configuration file
insert_driver() {
    if [ ! -f $cfgfile ]; then
        return
    fi

    # FIXME: generalize this so it does not have to be modified every time a
    #        new station type is added or new station options are added.
    db_get weewx/station_type
    if [ "$RET" != "" ]; then
        sed -i "s%station_type[ ]*=.*%station_type = $RET%" $cfgfile
        if [ "$RET" = "AcuRite" ]; then
            db_get weewx/acurite_model
            sed -i "/\[AcuRite\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
        fi
        if [ "$RET" = "CC3000" ]; then
            db_get weewx/cc3000_model
            sed -i "/\[CC3000\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
            db_get weewx/cc3000_port
            sed -i "/\[CC3000\]/,/\[.*\]/ s% port[ ]*=.*%    port = $RET%" $cfgfile
        fi
        if [ "$RET" = "FineOffsetUSB" ]; then
            db_get weewx/fousb_model
            sed -i "/\[FineOffsetUSB\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
        fi
        if [ "$RET" = "TE923" ]; then
            db_get weewx/te923_model
            sed -i "/\[TE923\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
        fi
        if [ "$RET" = "Ultimeter" ]; then
            db_get weewx/ultimeter_model
            sed -i "/\[Ultimeter\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
            db_get weewx/ultimeter_port
            sed -i "/\[Ultimeter\]/,/\[.*\]/ s% port[ ]*=.*%    port = $RET%" $cfgfile
        fi
        if [ "$RET" = "Vantage" ]; then
            db_get weewx/vantage_type
            sed -i "/\[Vantage\]/,/\[.*\]/ s% type[ ]*=.*%    type = $RET%" $cfgfile
            if [ "$RET" = "serial" ]; then
                db_get weewx/vantage_port
                sed -i "/\[Vantage\]/,/\[.*\]/ s% port[ ]*=.*%    port = $RET%" $cfgfile
            else
                db_get weewx/vantage_host
                sed -i "/\[Vantage\]/,/\[.*\]/ s% host[ ]*=.*%    host = $RET%" $cfgfile
            fi
        fi
        if [ "$RET" = "WMR100" ]; then
            db_get weewx/wmr100_model
            sed -i "/\[WMR100\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
        fi
        if [ "$RET" = "WMR300" ]; then
            db_get weewx/wmr300_model
            sed -i "/\[WMR300\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
        fi
        if [ "$RET" = "WMR9x8" ]; then
            db_get weewx/wmr9x8_model
            sed -i "/\[WMR9x8\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
            db_get weewx/wmr9x8_port
            sed -i "/\[WMR9x8\]/,/\[.*\]/ s% port[ ]*=.*%    port = $RET%" $cfgfile
        fi
        if [ "$RET" = "WS1" ]; then
            db_get weewx/ws1_port
            sed -i "/\[WS1\]/,/\[.*\]/ s% port[ ]*=.*%    port = $RET%" $cfgfile
        fi
        if [ "$RET" = "WS23xx" ]; then
            db_get weewx/ws23xx_model
            sed -i "/\[WS23xx\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
            db_get weewx/ws23xx_port
            sed -i "/\[WS23xx\]/,/\[.*\]/ s%[# ]*port[ ]*=.*%    port = $RET%" $cfgfile
        fi
        if [ "$RET" = "WS28xx" ]; then
            db_get weewx/ws28xx_model
            sed -i "/\[WS28xx\]/,/\[.*\]/ s%[# ]*model[ ]*=.*%    model = $RET%" $cfgfile
            db_get weewx/ws28xx_frequency
            sed -i "/\[WS28xx\]/,/\[.*\]/ s%[# ]*transceiver_frequency[ ]*=.*%    transceiver_frequency = $RET%" $cfgfile
        fi
    fi
}

install_weewxconf() {
    if [ ! -f $cfgfile ]; then
        return
    fi

    driver=weewx.drivers.simulator
    db_get weewx/station_type
    if [ "$RET" = "AcuRite" ]; then
        driver=weewx.drivers.acurite
    elif [ "$RET" = "CC3000" ]; then
        driver=weewx.drivers.cc3000
    elif [ "$RET" = "FineOffsetUSB" ]; then
        driver=weewx.drivers.fousb
    elif [ "$RET" = "TE923" ]; then
        driver=weewx.drivers.te923
    elif [ "$RET" = "Ultimeter" ]; then
        driver=weewx.drivers.ultimeter
    elif [ "$RET" = "Vantage" ]; then
        driver=weewx.drivers.vantage
    elif [ "$RET" = "WMR100" ]; then
        driver=weewx.drivers.wmr100
    elif [ "$RET" = "WMR300" ]; then
        driver=weewx.drivers.wmr300
    elif [ "$RET" = "WMR9x8" ]; then
        driver=weewx.drivers.wmr9x8
    elif [ "$RET" = "WS1" ]; then
        driver=weewx.drivers.ws1
    elif [ "$RET" = "WS23xx" ]; then
        driver=weewx.drivers.ws23xx
    elif [ "$RET" = "WS28xx" ]; then
        driver=weewx.drivers.ws28xx
    fi

    # default to US unit system
    units=us
    # get the system's unit system from debconf
    db_get weewx/units
    # sanitize the input.  for backward compatibility, we recognize the older
    # keywords 'US' and 'Metric', which might still be in the system's debconf
    # otherwise, ensure that debconf contains one of 'us', 'metric', or
    # 'metricwx'
    if [ "$RET" = "US" ]; then
        units=us
    elif [ "$RET" = "Metric" ]; then
        units=metric
    elif [ "$RET" = "metric" ]; then
        units=metric
    elif [ "$RET" = "metricwx" ]; then
        units=metricwx
    fi

    db_get weewx/location
    location=$RET

    db_get weewx/latlon
    lat=$(echo $RET | cut -d, -f1 | sed 's/^ //g' | sed 's/ $//g')
    lon=$(echo $RET | cut -d, -f2 | sed 's/^ //g' | sed 's/ $//g')

    db_get weewx/altitude
    altitude=$(echo $RET | cut -d, -f1 | sed 's/^ //g' | sed 's/ $//g')
    altitude_unit=$(echo $RET | cut -d, -f2 | sed 's/^ //g' | sed 's/ $//g')
    if [ "$altitude_unit" = "feet" ]; then
        altitude_unit=foot
    elif [ "$altitude_unit" = "meters" ]; then
        altitude_unit=meter
    elif [ "$altitude_unit" != "foot" -a "$altitude_unit" != "meter" ]; then
        altitude_unit=foot
    fi

    db_get weewx/register
    if [ "$RET" = 'true' ]; then
      register=y
      db_get weewx/station_url
      station_url_param="--station-url=$RET"
    else
      register=n
      station_url_param=" "
    fi

    $cfgapp station reconfigure --config=$cfgfile \
      --driver=$driver --units=$units --location="$location" \
      --latitude=$lat --longitude=$lon --altitude=$altitude,$altitude_unit \
      --register=$register $station_url_param \
      --no-prompt --no-backup

    insert_driver
}

# use weewx setup utilities to merge new features into existing weewx.conf.
# user will be prompted about whether to accept the new version or the previous
# configuration.
#
# if they choose existing, then they end up with:
#   weewx.conf           - previous config
#   weewx.conf.x.y.z     - new config
#
# if they choose new, then they end up with:
#   weewx.conf.dpkg-old  - previous config
#   weewx.conf           - new config
#
# new install:
#   weewx.conf           - new config filled with values from debconf
#   weewx.conf-new       - new config (created by dpkg rules)
#
# upgrade:
#   weewx.conf           - previous config
#   weewx.conf-new       - new config (created by dpkg rules)
#   weewx.conf-old-new   - old config upgraded to this version
#
merge_weewxconf() {
    if [ ! -f $cfgfile ]; then
        return
    fi

    if [ -f $cfgfile ]; then
        NEWVER=$($cfgapp --version | cut -d' ' -f2)
        OLDVER=$(get_conf_version $cfgfile)
        if dpkg --compare-versions $OLDVER lt $NEWVER; then
            # this is an old config, so create a maintainer's version
            if [ -f $cfgfile-$NEWVER ]; then
	        MNT=$OLDVER-$NEWVER
                echo "Creating maintainer config file as $cfgfile-$MNT"
                cp -p $cfgfile $cfgfile-$MNT
                $cfgapp station upgrade --config=$cfgfile-$MNT --dist-config=$cfgfile-$NEWVER --what=config --no-backup --yes
            fi
        else
            # this is a new config, so just insert debconf values into it
            echo "Using debconf configuration values from previous install"
            install_weewxconf
        fi
    fi
}

# precompile the bytecode
precompile() {
    rc=$(python3 -m compileall -q -x 'user' /usr/share/weewx)
    if [ "$rc" != "" ]; then
        echo "Pre-compile failed!"
        echo "$rc"
    fi
}

# get the version number from the specified file, without the debian revisions
get_conf_version() {
    v=$(grep '^version.*=' $1 | sed -e 's/\s*version\s*=\s*//' | sed -e 's/-.*//')
    if [ "$v" = "" ]; then
        # someone might have messed with the version string
        v="xxx"
    fi
    echo $v
}

# if this is an upgrade and the owner of the previous data is other than weewx
# or root, then use that user as the weewx user.  net effect is that we convert
# ownership to weewx:weewx for anything other than a previous install with
# customized ownership.
get_user() {
    if [ -d $WEEWX_HOME ]; then
        TMP_USER=$(stat -c "%U" $WEEWX_HOME)
        if [ "$TMP_USER" != "root" -a "$TMP_USER" != "weewx" -a "$TMP_USER" != "UNKNOWN" ]; then
            WEEWX_USER=$TMP_USER
            WEEWX_GROUP=$(stat -c "%G" $WEEWX_HOME)
        fi
    fi
    echo "Using $WEEWX_USER:$WEEWX_GROUP as user:group"
}

# create/modify the defaults file to match this installation.  if the file does
# not exist, then create it with our values.  if there are already values, then
# move it aside.
setup_defaults() {
    dflts=/etc/default/weewx
    if [ -f $dflts ]; then
        echo "Saving old defaults to ${dflts}-$ts"
        mv $dflts ${dflts}-$ts
    fi
    echo "Creating /etc/default/weewx"
    echo "WEEWX_PYTHON=python3" > $dflts
    echo "WEEWX_BINDIR=/usr/share/weewx" >> $dflts

    # the SysV rc script uses additional variables, so set values for them
    if [ "$1" = "init" ]; then
        grep -q "^WEEWX_CFGDIR=" $dflts || \
            echo "WEEWX_CFGDIR=/etc/weewx" >> $dflts
        grep -q "^WEEWX_RUNDIR=" $dflts || \
            echo "WEEWX_RUNDIR=/var/lib/weewx" >> $dflts
        grep -q "^WEEWX_USER=" $dflts || \
            echo "WEEWX_USER=$WEEWX_USER" >> $dflts
        grep -q "^WEEWX_GROUP=" $dflts || \
            echo "WEEWX_GROUP=$WEEWX_GROUP" >> $dflts
        grep -q "^WEEWX_INSTANCES=" $dflts || \
            echo "WEEWX_INSTANCES=\"weewx\"" >> $dflts
    fi
}

# create the user that the daemon will run as, but only if not already exist
create_user() {
    if ! getent group | grep -q "^$WEEWX_GROUP:"; then
        echo -n "Adding system group $WEEWX_GROUP..."
        addgroup --quiet --system $WEEWX_GROUP || true
        echo "done"
    fi
    if ! getent passwd | grep -q "^$WEEWX_USER:"; then
        echo -n "Adding system user $WEEWX_USER..."
        adduser --quiet --system --ingroup $WEEWX_GROUP \
                --no-create-home --home $WEEWX_HOME \
                --disabled-password weewx || true
        echo "done"
    fi
}

# add the user who is installing into the weewx group, if appropriate
add_to_group() {
    # add user only if the group is not a privileged group
    if [ "$WEEWX_GROUP" != "root" ]; then
        # see who is running the installation
        inst_user=$USER
        if [ "$SUDO_USER" != "" ]; then
            inst_user=$SUDO_USER
        fi
        # put the user who is doing the installation into the weewx group,
        # but only if it is not root or the weewx user.
        if [ "$inst_user" != "root" -a "$inst_user" != "$WEEWX_USER" ]; then
            # if user is already in the group, then skip it
            if ! getent group $WEEWX_GROUP | grep -q $inst_user; then
                echo "Adding user $inst_user to group $WEEWX_GROUP"
                usermod -aG $WEEWX_GROUP $inst_user
            else
                echo "User $inst_user is already in group $WEEWX_GROUP"
            fi
        fi
    fi
}

# put the init files in place
setup_init() {
    if [ "$1" = "systemd" ]; then
        # prefer /usr/lib but fall back to /lib
        dst="/usr/lib/systemd/system"
        if [ ! -d $dst ]; then
            dst="/lib/systemd/system"
        fi
        if [ -d $dst ]; then
            echo "Installing systemd units"
            for f in weewx.service weewx@.service; do
                sed \
 -e "s/User=.*/User=${WEEWX_USER}/" \
 -e "s/Group=.*/Group=${WEEWX_GROUP}/" \
 /etc/weewx/systemd/$f > $dst/$f
            done
            systemctl daemon-reload
        fi
    elif [ "$1" = "init" ]; then
        echo "Installing SysV rc script"
        cp /etc/weewx/init.d/weewx-multi /etc/init.d/weewx
        chmod 755 /etc/init.d/weewx
    fi
}

enable_init() {
    echo "Enabling startup using $1"
    if [ "$1" = "systemd" ]; then
	systemctl enable weewx > /dev/null
    elif [ "$1" = "init" ]; then
        update-rc.d weewx defaults > /dev/null
    fi
}

start_weewx() {
    echo "Starting weewxd using $1"
    if [ "$1" = "systemd" ]; then
	systemctl start weewx
    elif [ "$1" = "init" ]; then
        invoke-rc.d weewx start
    fi
}

# put the udev rules in place
setup_udev() {
    # prefer /usr/lib but fall back to /lib
    dst=/usr/lib/udev/rules.d
    if [ ! -d $dst ]; then
        dst=/lib/udev/rules.d
    fi
    if [ -d $dst ]; then
        echo "Installing udev rules"
        sed \
 -e "s/GROUP=\"weewx\"/GROUP=\"${WEEWX_GROUP}\"/" \
 /etc/weewx/udev/weewx.rules > $dst/60-weewx.rules
    fi
}

# create the skins if skins do not already exist
setup_skins() {
    if [ ! -d /etc/weewx/skins ]; then
        echo "Creating skins directory /etc/weewx/skins"
        cp -rp /usr/share/weewx/weewx_data/skins /etc/weewx
    fi
}

# create the user extensions directory if one does not already exist
setup_user_dir() {
    if [ ! -d $WEEWX_USERDIR ]; then
        echo "Creating user extension directory $WEEWX_USERDIR"
        mkdir -p $WEEWX_USERDIR
        cp /usr/share/weewx/weewx_data/bin/user/__init__.py $WEEWX_USERDIR
        cp /usr/share/weewx/weewx_data/bin/user/extensions.py $WEEWX_USERDIR
    fi
}

set_permissions() {
    usr=$1
    grp=$2
    dir=$3
    find $3 -type f -exec chmod 664 {} \;
    find $3 -type d -exec chmod 2775 {} \;
    chmod 2775 $dir
    chown -R $usr:$grp $dir
}

# create the database directory
setup_database_dir() {
    echo "Configuring database directory $WEEWX_HOME"
    mkdir -p $WEEWX_HOME
    set_permissions $WEEWX_USER $WEEWX_GROUP $WEEWX_HOME
}

# create the reporting directory
setup_reporting_dir() {
    echo "Configuring reporting directory $WEEWX_HTMLDIR"
    mkdir -p $WEEWX_HTMLDIR
    set_permissions $WEEWX_USER $WEEWX_GROUP $WEEWX_HTMLDIR
}

# set the permissions on the configuration, skins, and extensions
set_config_permissions() {
    echo "Setting permissions $WEEWX_USER:$WEEWX_GROUP on /etc/weewx"
    set_permissions $WEEWX_USER $WEEWX_GROUP /etc/weewx
}

# if there are any existing extensions in the V4 location, copy them to the
# V5 location, then move aside the old location
migrate_extensions() {
    if [ -d /usr/share/weewx/user ]; then
        echo "Migrating old extensions to $WEEWX_USERDIR"
        mkdir -p $WEEWX_USERDIR
        cp -rp /usr/share/weewx/user/* $WEEWX_USERDIR
        echo "Saving old extensions to /usr/share/weewx/user-$ts"
        mv /usr/share/weewx/user /usr/share/weewx/user-$ts
    fi
}

# check for systemd and/or sysV init files that might affect the init setup
# that we install.
check_init() {
    files_to_check=""
    if [ "$1" = "systemd" ]; then
        files_to_check="/etc/init.d/weewx-multi /etc/init.d/weewx /etc/systemd/system/weewx.service"
    elif [ "$1" = "init" ]; then
        files_to_check="/etc/init.d/weewx-multi"
    fi
    files=""
    for f in $files_to_check; do
        if [ -f $f ]; then
            files="$files $f"
        fi
    done
    if [ "$files" != "" ]; then
        echo "The following files might interfere with the init configuration:"
        for f in $files; do
            echo "  $f"
        done
    fi
}


# see which init system is running
pid1=none
if [ -d /run/systemd/system ]; then
    pid1=systemd
else
    pid1=init
fi

case "$1" in
    configure)
        get_user
        setup_defaults $pid1

        if [ "$2" != "" ]; then
            # this is an upgrade so create a maintainers version by merging
            merge_weewxconf
            # migrate any extensions from V4 location to V5
            migrate_extensions
        else
            # virgin install so insert debconf values into the config file
            install_weewxconf
        fi

        create_user
        add_to_group
        setup_init $pid1
        setup_udev
        setup_skins
        setup_user_dir
        setup_database_dir
        setup_reporting_dir
        precompile
        set_config_permissions
        enable_init $pid1
        start_weewx $pid1
        check_init $pid1
        ;;

    abort-remove)
        ;;
esac

# let debconf know that we are finished
db_stop

#DEBHELPER#

exit 0