pp.back.systemd.svc

#@ pp_systemd_make_service_file(): create systemd service file
pp_systemd_make_service_file() {
    local svc f

    if [ "${pp_systemd_disabled:-false}" = "true" ]; then
	return
    fi

    svc="$1"
    f="${pp_systemd_service_dir:-/opt/quest/libexec/vas}/$svc.service"
    pp_add_file_if_missing $f run 644 v || return 0

    cat <<. >$pp_destdir$f
# Systemd unit file for $svc

[Unit]
Description=${pp_systemd_service_description:-"systemd service file for $svc"}
${pp_systemd_service_man:+"Documentation=$pp_systemd_service_man"}
${pp_systemd_service_documentation:+"Documentation=$pp_systemd_service_documentation"}
${pp_systemd_service_requires:+"Requires=$pp_systemd_service_requires"}
After=${pp_systemd_service_after:-"syslog.target network.target auditd.service"}
${pp_systemd_service_before:+"Before=$pp_systemd_service_before"}
${pp_systemd_service_wants:+"Wants=$pp_systemd_service_wants"}
${pp_systemd_service_conflicts:+"Conflicts=$pp_systemd_service_conflicts"}

[Service]
ExecStart=${pp_systemd_service_exec:-"/opt/quest/sbin/$svc"} ${pp_systemd_service_exec_args}
KillMode=${pp_systemd_service_killmode:-process}
Type=${pp_systemd_service_type:-forking}
${pp_systemd_service_pidfile:+"PIDFile=$pp_systemd_service_pidfile"}

[Install]
WantedBy=${pp_systemd_system_target:-"multi-user.target"}
.
}

#@ pp_systemd_service_init_common(): emit common code for install/uninstall
pp_systemd_service_init_common () {
    cat <<.

        _pp_systemd_init () {
	    systemd_service_dir=${pp_systemd_service_dir:-/opt/quest/libexec/vas}
            systemd_target=${pp_systemd_system_target:-"multi-user.target"}
            systemd_target_wants="\${systemd_target}.wants"

            pkg_config_cmd=${pp_systemd_pkg_config_cmd:-"\$(command -v pkg-config)"}
            systemctl_cmd=${pp_systemd_systemctl_cmd:-"\$(command -v systemctl)"}

            # See if pkg-config is installed to get the default locations for this OS, if not installed then just use what we hard code.
            # So far works on Debian 8, OpenSuse12.3, Ubuntu 16.04, RHEL 7.3
            # See systemd wiki for more OS interactions https://en.wikipedia.org/wiki/Systemd
            if [ -x "\$pkg_config_cmd" ]; then
                systemd_system_unit_dir="\$(pkg-config systemd --variable=systemdsystemunitdir)"
                systemd_system_conf_dir="\$(pkg-config systemd --variable=systemdsystemconfdir)"
            fi

            #if pkg-config does not exist or if the \$pkg_config_cmd command returns nothing
            if test -z "\$systemd_system_unit_dir"; then
              systemdsystemunitdirs="/lib/systemd/system /usr/lib/systemd/system"
              for dir in \$systemdsystemunitdirs; do
                  if [ -d "\$dir/\$systemd_target_wants" ]; then
                    systemd_system_unit_dir="\$dir"
                    break
                  fi
              done
            fi

            # In the case where \$systemd_system_conf_dir is empty hard code the path
            if test -z "\$systemd_system_conf_dir"; then
                systemd_system_conf_dir="/etc/systemd/system"
            fi

            # if the \$svc.pp file defines the systemd unit dir then use it.
            ${pp_systemd_system_unit_dir:+"# systemd_system_unit_dir defined by variable pp_systemd_system_unit_dir from the \$svc.pp file"}
            systemd_system_unit_dir="${pp_systemd_system_unit_dir:-"\$systemd_system_unit_dir"}"

            # if the \$svc.pp file defines the systemd conf dir then use it.
            ${pp_systemd_system_conf_dir:+"# systemd_system_conf_dir defined by variable pp_systemd_system_conf_dir from the \$svc.pp file"}
            systemd_system_conf_dir="${pp_systemd_system_conf_dir:-"\$systemd_system_conf_dir"}"
        }
.
}

#@ pp_systemd_service_install_common(): emit common code for service install
pp_systemd_service_install_common () {
    if [ "${pp_systemd_disabled:-false}" = "true" ]; then
	cat<<'.'

        # systemd support disabled
        _pp_systemd_init () {
            return
        }

        _pp_systemd_install () {
            return
        }

        _pp_systemd_enable () {
            return
        }
.
	return
    fi

    pp_systemd_service_init_common

    cat<<'.'

        _pp_systemd_install () {
            local svc="$1"

            # If $systemctl_cmd is not set, then call _pp_systemd_init. If still not
            # set, we do not know where the systemctl command is so do nothing;
            # systemd must not be on this system.
            if test -z "$systemctl_cmd"; then
                _pp_systemd_init
            fi

            if test -x "$systemctl_cmd" && test -d "$systemd_system_conf_dir/$systemd_target_wants"; then
                # If our service file still exists (upgrade) remove the link/file and systemctl
                # will recreate it if/when we enable the $svc service.
                rm -f "$systemd_system_conf_dir/$systemd_target_wants/$svc.service"

                # Copy the $svc.service file to the correct systemd_system_unit_dir location
                if [ "x$systemd_service_dir" != "x$systemd_system_unit_dir" ]; then
                    cp -f "$systemd_service_dir/$svc.service" "$systemd_system_unit_dir/$svc.service"
                    chmod 644 "$systemd_system_unit_dir/$svc.service"
                fi
            fi
        }

        _pp_systemd_enable () {
            local svc="$1"
            local RUNNING=0

            # If $systemctl_cmd is not set, then call _pp_systemd_init. If still not
            # set, we do not know where the systemctl command is so do nothing;
            # systemd must not be on this system.
            if test -z "$systemctl_cmd"; then
                _pp_systemd_init
            fi

            if test -x "$systemctl_cmd" && test -f "$systemd_system_unit_dir/$svc.service"; then
                # stop the daemon using the old init script before enabling systemd for the service
                # we do this so we do not "orphan" the process. Because init started it and if we enable systemd
                # it will not know about this process and will not be able to stop it.
                if [ -x "/etc/init.d/$svc" ]; then
                    output="$(/etc/init.d/$svc status 2>&1)"
                    RUNNING=$?
                    if [ $RUNNING -eq 0 ]; then
                        case "$output" in
                            *"not running"*)
                                # systemd is reporting the status (compatibility package is installed)
                                RUNNING=1
                                ;;
                            *)  # it is really running
                                /etc/init.d/$svc stop > /dev/null 2>&1
                                ;;
                        esac
                    fi
                fi

                # If the service is not running according to its sysv script (eg. systemd service
                # is not using a pidfile the sysv script needs), or its sysv script is not present any more,
                # check how systemd thinks.
                # We also try to restart the service in case something went wrong with it.
                if $systemctl_cmd is-active "$svc" >/dev/null 2>&1 || $systemctl_cmd is-failed "$svc" >/dev/null 2>&1; then
                        $systemctl_cmd stop "$svc" >/dev/null 2>&1
                        RUNNING=0
                fi

                # Enable the $svc.service
                $systemctl_cmd daemon-reload >/dev/null 2>&1

                # We do not need the init.d script any more, and it causes problems on SLES
                # where systemd sysv compatibility is enforced and broken on default installs
                rm -f "/etc/init.d/$svc"

                $systemctl_cmd enable $svc.service >/dev/null 2>&1

                # Now that the service has been enabled, start it again if it was running before.
                if [ $RUNNING -eq 0 ]; then
                    $systemctl_cmd start $svc.service >/dev/null 2>&1
                fi
            fi
        }
.
}

#@ pp_systemd_service_remove_common(): emit common code for service removal
pp_systemd_service_remove_common () {
    if [ "${pp_systemd_disabled:-false}" = "true" ]; then
	cat<<'.'

        # systemd support disabled
        _pp_systemd_init () {
            return
        }

        _pp_systemd_disable () {
            return
        }

        _pp_systemd_remove () {
            return
        }
.
	return
    fi

    pp_systemd_service_init_common

    cat<<'.'

        _pp_systemd_disable () {
            local svc="$1"

            # If $systemctl_cmd is not set, then call _pp_systemd_init.
            # If still not set, we do not know where the systemctl command
            # is so do nothing; systemd must not be on this system.
            if test -z "$systemctl_cmd"; then
                _pp_systemd_init
            fi

            systemd_service_file="$systemd_system_conf_dir/$systemd_target_wants/$svc.service"

            # Remove systemd symlink (enabled) unit service file
            if test -e $systemd_service_file; then
                # Disable the $svc service
                if test -x "$systemctl_cmd"; then
                    $systemctl_cmd disable $svc.service > /dev/null 2>&1
                else
                    # For some reason systemctl is not install but our service file exists
                    # Just delete the symlink then
                    rm -f "$systemd_service_file"
                fi
            fi
        }

        _pp_systemd_remove () {
            local svc="$1"

            # If $systemctl_cmd is not set, then call _pp_systemd_init.
            # If still not set, we do not know where the systemctl command
            # is so do nothing; systemd must not be on this system.
            if test -z "$systemctl_cmd"; then
                _pp_systemd_init
            fi

            $systemctl_cmd stop $svc.service > /dev/null 2>&1

            # Remove the systemd unit service file
            if [ "x$systemd_service_dir" != "x$systemd_system_unit_dir" ]; then
                rm -f "$systemd_system_unit_dir/$svc.service"
            fi

            if test -x "$systemctl_cmd"; then
                $systemctl_cmd daemon-reload
                $systemctl_cmd reset-failed $svc.service >/dev/null 2>&1 || true
            fi
        }
.
}