github.com/klaytn/klaytn@v1.12.1/build/rpm/etc/init.d/kend

#!/bin/bash
#
# kend         Startup script for the ken
#
# chkconfig: - 85 15
# description : kend is the Klaytn endpoint node daemon
#
# processname: kend
# config:  /etc/kend/conf/kend.conf
# pidfile: /var/run/kend.pid
#

# Source function library.
. /etc/init.d/functions

if [ -f /etc/kend/conf/kend.conf ]; then
        . /etc/kend/conf/kend.conf
fi

ken=/usr/bin/ken
prog=kend
lockfile=${LOCKFILE-/var/lock/subsys/kend}
pidfile=${PIDFILE-/var/run/kend.pid}
auto_restart_daemon_pidfile=/var/run/restart_daemon_kend.pid
RETVAL=0
STOP_TIMEOUT=${STOP_TIMEOUT-10}

__pid_run() {
  __pids_var_run $prog $pidfile
}

__auto_restart_daemon_pid_run() {
    unset auto_restart_daemon_pid
    if [ ! -f $auto_restart_daemon_pidfile ]; then
        return
    fi
    AUTO_RESTART_DAEMON_PID_NUM=$(cat $auto_restart_daemon_pidfile)
    if [[ ! -z "$AUTO_RESTART_DAEMON_PID_NUM" ]]; then
        export auto_restart_daemon_pid=$(ps -p $AUTO_RESTART_DAEMON_PID_NUM -o pid=)
    fi
}
#------------------------Related Auto restart daemon functions-----------------------------
__auto_restart_daemon() {
    local backOffTime=$AUTO_RESTART_INTERVAL
    local coeff=2
    while :
    do
        sleep 1
        __pid_run
        if [ -z "$pid" ]; then
            echo "INFO[`date`] node[${PID_NUM}] is down"
            if [ -f $pidfile ]; then
                echo "INFO[`date`] remove redundant pid file"
                rm -f ${lockfile} ${pidfile}
            fi
            echo "INFO[`date`] Sleep for backOffTime.... ${backOffTime} seconds."
            sleep $backOffTime
            echo -n "INFO[`date`] "
            start_node
            backOffTime=$(echo $backOffTime $coeff | awk '{printf "%.1f\n",$1*$2}')

            echo "INFO[`date`] backOffTime = ${backOffTime}, Restarted node pid = ${PID_NUM}"
            PID_NUM=$(cat $pidfile)
            echo ""
        fi
    done
}

start_auto_restart_daemon() {
    __auto_restart_daemon_pid_run
    if [ -z $auto_restart_daemon_pid ]; then
        __auto_restart_daemon >> ${LOG_DIR}/restart_daemon.out 2>&1 &
        disown
        AUTO_RESTART_DAEMON_PID_NUM=$!
        AUTO_RESTART_DAEMON_RETVAL=$?

        set +f
        if [ $AUTO_RESTART_DAEMON_RETVAL = 0 ]; then
            echo $AUTO_RESTART_DAEMON_PID_NUM > ${auto_restart_daemon_pidfile}
            echo "Success to start auto restart daemon."
        else
            echo "Fail to start auto restart daemon."
        fi
    fi
}

stop_auto_restart_daemon() {
    echo -n "Shutting down auto restart daemon: "
    killproc -p ${auto_restart_daemon_pidfile} -d ${STOP_TIMEOUT}
    RETVAL=$?
    echo
    [ $RETVAL = 0 ] && rm -f ${auto_restart_daemon_lockfile} ${auto_restart_daemon_pidfile}
}

status_auto_restart_daemon() {
    __auto_restart_daemon_pid_run
    if [ -n "$auto_restart_daemon_pid" ]; then
        echo "auto restart daemon is running."
    else
        echo "auto restart daemon is down."
    fi
}

#------------------------Related to Klaytn node functions-----------------------------

set -f
OPTIONS=""

if [[ ! -z $METRICS ]] && [[ $METRICS -eq 1 ]]; then
    OPTIONS="$OPTIONS --metrics"
fi

if [[ ! -z $PROMETHEUS ]] && [[ $PROMETHEUS -eq 1 ]]; then
    OPTIONS="$OPTIONS --prometheus"
fi

if [[ ! -z $DB_NO_PARALLEL_WRITE ]] && [[ $DB_NO_PARALLEL_WRITE -eq 1 ]]; then
    OPTIONS="$OPTIONS --db.no-parallel-write"
fi

if [[ ! -z $MULTICHANNEL ]] && [[ $MULTICHANNEL -eq 1 ]]; then
    OPTIONS="$OPTIONS --multichannel"
fi

if [[ ! -z $RPC_ENABLE ]] && [[ $RPC_ENABLE -eq 1 ]]; then
    OPTIONS="$OPTIONS --rpc"
    RPC_API=`echo $RPC_API | tr -d "[:space:]"`
    if [ ! -z $RPC_API ]; then
        OPTIONS="$OPTIONS --rpcapi $RPC_API"
    fi
    if [ ! -z $RPC_PORT ]; then
        OPTIONS="$OPTIONS --rpcport $RPC_PORT"
    fi
    if [ ! -z $RPC_ADDR ]; then
        OPTIONS="$OPTIONS --rpcaddr $RPC_ADDR"
    fi
    if [ ! -z $RPC_CORSDOMAIN ]; then
        OPTIONS="$OPTIONS --rpccorsdomain $RPC_CORSDOMAIN"
    fi
    if [ ! -z $RPC_VHOSTS ]; then
        OPTIONS="$OPTIONS --rpcvhosts $RPC_VHOSTS"
    fi
    if [ ! -z $RPC_CONCURRENCYLIMIT ]; then
        OPTIONS="$OPTIONS --rpc.concurrencylimit $RPC_CONCURRENCYLIMIT"
    fi
    if [ ! -z $RPC_READ_TIMEOUT ]; then
        OPTIONS="$OPTIONS --rpcreadtimeout $RPC_READ_TIMEOUT"
    fi
    if [ ! -z $RPC_WRITE_TIMEOUT ]; then
        OPTIONS="$OPTIONS --rpcwritetimeout $RPC_WRITE_TIMEOUT"
    fi
    if [ ! -z $RPC_IDLE_TIMEOUT ]; then
        OPTIONS="$OPTIONS --rpcidletimeout $RPC_IDLE_TIMEOUT"
    fi
    if [ ! -z $RPC_EXECUTION_TIMEOUT ]; then
        OPTIONS="$OPTIONS --rpcexecutiontimeout $RPC_EXECUTION_TIMEOUT"
    fi
fi

if [[ ! -z $WS_ENABLE ]] && [[ $WS_ENABLE -eq 1 ]]; then
    OPTIONS="$OPTIONS --ws"
    WS_API=`echo $WS_API | tr -d "[:space:]"`
    if [ ! -z $WS_API ]; then
        OPTIONS="$OPTIONS --wsapi $WS_API"
    fi
    if [ ! -z $WS_PORT ]; then
        OPTIONS="$OPTIONS --wsport $WS_PORT"
    fi
    if [ ! -z $WS_ADDR ]; then
        OPTIONS="$OPTIONS --wsaddr $WS_ADDR"
    fi
    if [ ! -z $WS_ORIGINS ]; then
        OPTIONS="$OPTIONS --wsorigins $WS_ORIGINS"
    fi
fi

# Cypress network => NETWORK_ID is null && NETWORK = "cypress"
# Baobab network => NETWORK_ID is null && NETWORK = "baobab"
# Else => private network
if [[ -z $NETWORK_ID ]]; then
    if [[ $NETWORK == "baobab" ]]; then
        OPTIONS="$OPTIONS --baobab"
    elif [[ $NETWORK == "cypress" ]]; then
        OPTIONS="$OPTIONS --cypress"
    else
        echo
        echo "[ERROR] network id is not specified and network is not available."
        echo "Available network: baobab, cypress"
        exit 1
    fi
else
    OPTIONS="$OPTIONS --networkid $NETWORK_ID"
    echo "[INFO] creating a private network: $NETWORK_ID"
    if [[ ! -z $NETWORK ]]; then
        echo
        echo "[WARN] ignoring the specified network: $NETWORK"
    fi
fi

if [ ! -z $DATA_DIR ]; then
    OPTIONS="$OPTIONS --datadir $DATA_DIR"
fi

if [ ! -z $PORT ]; then
    OPTIONS="$OPTIONS --port $PORT"
fi

if [ ! -z $SUBPORT ]; then
    OPTIONS="$OPTIONS --subport $SUBPORT"
fi

if [ ! -z $SERVER_TYPE ]; then
    OPTIONS="$OPTIONS --srvtype $SERVER_TYPE"
fi

if [ ! -z $VERBOSITY ]; then
    OPTIONS="$OPTIONS --verbosity $VERBOSITY"
fi

if [ ! -z $TXPOOL_EXEC_SLOTS_ALL ]; then
    OPTIONS="$OPTIONS --txpool.exec-slots.all $TXPOOL_EXEC_SLOTS_ALL"
fi

if [ ! -z $TXPOOL_NONEXEC_SLOTS_ALL ]; then
    OPTIONS="$OPTIONS --txpool.nonexec-slots.all $TXPOOL_NONEXEC_SLOTS_ALL"
fi

if [ ! -z $TXPOOL_EXEC_SLOTS_ACCOUNT ]; then
    OPTIONS="$OPTIONS --txpool.exec-slots.account $TXPOOL_EXEC_SLOTS_ACCOUNT"
fi

if [ ! -z $TXPOOL_NONEXEC_SLOTS_ACCOUNT ]; then
    OPTIONS="$OPTIONS --txpool.nonexec-slots.account $TXPOOL_NONEXEC_SLOTS_ACCOUNT"
fi

if [ ! -z $TXPOOL_LIFE_TIME ]; then
    OPTIONS="$OPTIONS --txpool.lifetime $TXPOOL_LIFE_TIME"
fi

if [ ! -z $SYNCMODE ]; then
    OPTIONS="$OPTIONS --syncmode $SYNCMODE"
fi

if [ ! -z $MAXCONNECTIONS ]; then
    OPTIONS="$OPTIONS --maxconnections $MAXCONNECTIONS"
fi

if [ ! -z $LDBCACHESIZE ]; then
    OPTIONS="$OPTIONS --db.leveldb.cache-size $LDBCACHESIZE"
fi

if [[ ! -z $SC_MAIN_BRIDGE ]] && [[ $SC_MAIN_BRIDGE -eq 1 ]]; then
    OPTIONS="$OPTIONS --mainbridge --mainbridgeport $SC_MAIN_BRIDGE_PORT"
    if [[ ! -z $SC_MAIN_BRIDGE_INDEXING ]] && [[ $SC_MAIN_BRIDGE_INDEXING -eq 1 ]]; then
        OPTIONS="$OPTIONS --childchainindexing"
    fi
fi

if [[ ! -z $NO_DISCOVER ]] && [[ $NO_DISCOVER -eq 1 ]]; then
    OPTIONS="$OPTIONS --nodiscover"
fi

if [[ ! -z $BOOTNODES ]] && [[ $BOOTNODES != "" ]]; then
    OPTIONS="$OPTIONS --bootnodes $BOOTNODES"
fi

if [[ ! -z $ADDITIONAL ]] && [[ $ADDITIONAL != "" ]]; then
    OPTIONS="$OPTIONS $ADDITIONAL"
fi

if [[ ! -z $AUTO_RESTART ]] && [[ $AUTO_RESTART -eq 1 ]]; then
    OPTIONS="$OPTIONS --autorestart.enable"
fi

if [[ ! -z $LOG_ROTATE ]] && [[ $LOG_ROTATE -eq 1 ]]; then
    OPTIONS="$OPTIONS --log.rotate"
    if [[ ! -z $LOG_MAXSIZE ]]; then
      OPTIONS="$OPTIONS --log.maxsize $LOG_MAXSIZE"
    fi
    if [[ ! -z $LOG_MAXBACKUP ]]; then
      OPTIONS="$OPTIONS --log.maxbackup $LOG_MAXBACKUP"
    fi
    if [[ ! -z $LOG_MAXAGE ]]; then
      OPTIONS="$OPTIONS --log.maxage $LOG_MAXAGE"
    fi
    if [[ ! -z $LOG_COMPRESS ]] && [[ $LOG_COMPRESS -eq 1 ]]; then
      OPTIONS="$OPTIONS --log.compress"
    fi
fi

BASEDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
CURRENTFILE=`basename "$0"`
OPTIONS="$OPTIONS --autorestart.daemon.path $BASEDIR/$CURRENTFILE"
set +f

start_node() {
    echo -n "Starting $prog: "
    if [ ! -d ${LOG_DIR} ]; then
            mkdir -p ${LOG_DIR}
    fi

    __pids_var_run "$prog" "$pidfile"
    [ -n "$pid" ] && echo && return

    set -f
    OPTIONS="$OPTIONS --log.file ${LOG_DIR}/kend.out"
    TERM="dumb" $ken $OPTIONS >> ${LOG_DIR}/kend.out 2>&1 &
    RETVAL=$?
    PIDNUM=$!
    set +f
    if [ $RETVAL = 0 ]; then
            echo $PIDNUM > ${pidfile}
            touch ${lockfile}
            success "$prog startup"
    else
            failure "$prog startup"
    fi
    echo
    return $RETVAL
}

stop_node() {
    echo -n "Shutting down $prog: "
    killproc -p ${pidfile} -d ${STOP_TIMEOUT} $ken
    RETVAL=$?
    echo
    [ $RETVAL = 0 ] && rm -f ${lockfile} ${pidfile}
}

#--------------------- Public functions --------------------------
start() {
    if [ ! -z $AUTO_RESTART_NODE ] && [[ $AUTO_RESTART_NODE -eq 1 ]]; then
        start_auto_restart_daemon
    else
        start_node
    fi
}

stop() {
    if [ ! -z $AUTO_RESTART_NODE ] && [[ $AUTO_RESTART_NODE -eq 1 ]]; then
        stop_auto_restart_daemon
    fi
    stop_node
}

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    status)
        status -p ${pidfile} -l ${lockfile} $ken
        if [ ! -z $AUTO_RESTART_NODE ] && [[ $AUTO_RESTART_NODE -eq 1 ]]; then
          status_auto_restart_daemon
        fi
        ;;
    restart)
        stop
        start
        ;;
    *)
        echo "Usage: $prog {start|stop|restart|status}"
        exit 1
        ;;
esac
exit $?