odenos

#! /bin/sh

# Copyright 2015 NEC Corporation.                                          #
#                                                                          #
# Licensed under the Apache License, Version 2.0 (the "License");          #
# you may not use this file except in compliance with the License.         #
# You may obtain a copy of the License at                                  #
#                                                                          #
#   http://www.apache.org/licenses/LICENSE-2.0                             #
#                                                                          #
# Unless required by applicable law or agreed to in writing, software      #
# distributed under the License is distributed on an "AS IS" BASIS,        #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and      #
# limitations under the License.                                           #

## required the POSIX shell but may use bash or dash

unset http_proxy

if [ -z "${JAVA_HOME}" ] ;then
    echo "set JAVA_HOME." >&2
    exit 1
fi

JAVAC=$JAVA_HOME/bin/javac
JAVA=$JAVA_HOME/bin/java
PYTHON=python
MVN=mvn
TREMA=${TREMA:-~/trema-edge/trema}	# DO NOT enclose by quote(")

RUN_DIR=`pwd`
RUN_SCRIPT_NAME="${0##*/}"
RUN_SCRIPT_DIR="${0%${RUN_SCRIPT_NAME}}"
cd ${RUN_SCRIPT_DIR}
ODENOS_ROOT=`pwd`
MAX_WAIT_COUNT=30
DEBUG="${DEBUG:-OFF}"

ODENOS_CONF=$ODENOS_ROOT/etc
ODENOS_CONF_FILE=$ODENOS_CONF/odenos.conf
ODENOS_CONF_FILE_TMP=$ODENOS_CONF/odenos.conf.tmp
ODENOS_LIB=$ODENOS_ROOT/lib
ODENOS_LOG=var/log
ODENOS_TMP=var/tmp
REST_HOST=localhost
REST_PORT=10080
REST_ROOT=.

ODENOS_OPT="-Xms512m -Xmx512m -server"
ODENOS_MAIN=org.o3project.odenos.core.Odenos
FILE_ODENOS_SYSTEM_PID=$ODENOS_TMP/odenos_system.pid
ODENOS_MAIN_PY="${ODENOS_LIB}/python/org/o3project/odenos/core/odenos.py"
ODENOS_MAIN_RB="${ODENOS_LIB}/ruby/org/o3project/odenos/core/odenos.rb"

SYSTEM_MANAGER_ID=systemmanager
MANAGER=$SYSTEM_MANAGER_ID
MANAGER_ENABLED=true
HOST_M=localhost
PORT_M=6379
HOST_B=null
PORT_B=0
MONITOR=false
MONITOR_LOGGING=""
ZOOKEEPER_HOST=""
ZOOKEEPER_PORT=""
ZOOKEEPER_EMBED=""
ZOOKEEPER_LOG=var/zookeeper
# Refer to http://zookeeper.apache.org/doc/r3.3.1/zookeeperAdmin.html
# log file size 100KBytes, snapshot per 100 transactions
ZOOKEEPER_OPT="-Dzookeeper.preAllocSize=100 -Dzookeeper.snapCount=100"

TXOFFSET_SYSTEM=0000000

PROC_CNT=0
ODENOS_PROCESS=
#PROC_NAME_N=
#PROC_TYPE_N=
#PROC_DIRS_N=


##########################################################################
# common functions                                                       #
##########################################################################
check_pid_file()
{
    pid_file=$1
    if [ -f $pid_file ] ;then
	pid=`cat $pid_file`
	kill -0 $pid > /dev/null 2>&1
    else
	return 1
    fi
}

read_config_file()
{
    local res PROC_NAME PROC_TYPE PROC_DIRS idx

    [ -f $ODENOS_CONF_FILE ] || return 1

    count=0
    PROC_CNT=0
    ODENOS_PROCESS=","
    while read line ;do
        echo "${line}" | grep -E "^\s*(#|$)" > /dev/null
        res=$?
        if [ ${res} -eq 0 ] ;then
            continue
        fi

        KEY=`echo $line | cut -d " " -f 1 | tr -d " "`
        VAL=`echo $line | awk '{print $2}'`
        case "$KEY" in
        "PROCESS")
            count=$(( $count + 1 ))
            PROC_NAME=`echo $VAL | cut -d "," -f 1 | tr -d " "`
            PROC_TYPE=`echo $VAL | cut -d "," -f 2 | tr -d " "`
            PROC_DIRS=`echo $VAL | cut -d "," -f 3- | tr -d " "`
            case "${ODENOS_PROCESS}" in
            *,"${PROC_NAME}":[1-9],*|*,"${PROC_NAME}":[1-9][0-9],*|*,"${PROC_NAME}":[1-9][0-9][0-9],*)
                idx="${ODENOS_PROCESS##*,${PROC_NAME}:}" ; idx="${idx%%,*}"
                if [ "${PROC_TYPE}" != "$( eval echo "\${PROC_TYPE_${idx}}" )" ] ;then
                    echo "PROC_TYPE is unmatched: ${line} [${count}] (ignored)" >&2
                    continue
                fi
                eval "PROC_DIRS_${idx}=\"\${PROC_DIRS_${idx}},${PROC_DIRS}\""
                ;;
            *)
                PROC_CNT=$(( PROC_CNT + 1 ))
                eval "PROC_NAME_${PROC_CNT}=\"${PROC_NAME}\""
                eval "PROC_TYPE_${PROC_CNT}=\"${PROC_TYPE}\""
                eval "PROC_DIRS_${PROC_CNT}=\"${PROC_DIRS}\""
                ODENOS_PROCESS="${ODENOS_PROCESS}${PROC_NAME}:${PROC_CNT},"
                ;;
            esac
            ;;
        "MANAGER")
            MANAGER="${VAL}"
            if [ -z "${MANAGER}" ] ;then
                MANAGER=$SYSTEM_MANAGER_ID
            fi
            ;;
        "manager.disabled")
            unset MANAGER_ENABLED
            ;;
        "pubsub.server.host")
            HOST_M="${VAL}"
            ;;
        "pubsub.server.port")
            PORT_M="${VAL}"
            ;;
        "pubsub.server.host.backup")
            HOST_B="${VAL}"
            ;;
        "pubsub.server.port.backup")
            PORT_B="${VAL}"
            ;;
        "rest.host")
            REST_HOST="${VAL}"
            ;;
        "rest.root")
            REST_ROOT="${VAL}"
            ;;
        "rest.root")
            REST_ROOT="${VAL}"
            ;;
        "monitor")
            MONITOR=true
            ;;
        "monitor.logging")
            MONITOR_LOGGING="-l ${VAL}"
            ;;
        "zookeeper.host")
            ZOOKEEPER_HOST="-z ${VAL}"
            ;;
        "zookeeper.port")
            ZOOKEEPER_PORT="-n ${VAL}"
            ;;
        "zookeeper.embed")
            ZOOKEEPER_EMBED="-e"
            ;;
        *)
            ;;
        esac
    done < "${ODENOS_CONF_FILE}"
    ODENOS_PROCESS="${ODENOS_PROCESS#,}" ; ODENOS_PROCESS="${ODENOS_PROCESS%,}"
    ODENOS_PROCESS=$( IFS=, ; echo ${ODENOS_PROCESS} )

    case "${DEBUG}" in
    ON|on|YES|yes)
        echo "DEBUG: ODENOS_PROCESS=[${ODENOS_PROCESS}]" >&2
        ;;
    esac
    idx=0
    while [ ${idx} -lt ${PROC_CNT} ] ;do
        idx=$(( idx + 1 ))
        eval PROC_NAME="\${PROC_NAME_${idx}}"
        eval PROC_TYPE="\${PROC_TYPE_${idx}}"
        eval PROC_DIRS="\${PROC_DIRS_${idx}}"
        case "${DEBUG}" in
        ON|on|YES|yes)
            echo "DEBUG: name=${PROC_NAME}, type=${PROC_TYPE}, dirs=[${PROC_DIRS}]" >&2
            ;;
        esac
    done
}

set_classpath()
{
    CLASSPATH=.:`echo \`ls lib/java/*\` | tr " " :`:$CLASSPATH
    export CLASSPATH
}

purge_zk_log()
{
    # Purges ZooKeeper's transaction logs
     $JAVA -Dlog4j.configurationFile=file:${ODENOS_CONF}/log4j2_java.yaml \
           -Dlog4j2_app.log=$1 \
           org.apache.zookeeper.server.PurgeTxnLog \
	   ${ZOOKEEPER_LOG} ${ZOOKEEPER_LOG} -n 3
}

get_txoffset()
{
    local ret_val txoffset reply_code

    ret_val=0
    txoffset="$( curl http://${REST_HOST}:${REST_PORT}/systemmanager/sequence/offset -w ":%{response_code}\n" 2>/dev/null )"
    reply_code="${txoffset##*:}"
    txoffset="${txoffset%:${reply_code}}" ; txoffset="${txoffset#\"}" ; txoffset="${txoffset%\"}"
    case "${reply_code}" in
    200)
	echo "${txoffset}"
	;;
    000|404)    # 000 is not connected
	ret_val=10
	;;
    *)
	echo "Failed get TXID offset: ${reply_code}" >&2
	ret_val=1
	;;
    esac

    return ${ret_val}
}


##########################################################################
# main functions                                                         #
##########################################################################
start_system()
{
    if check_pid_file $FILE_ODENOS_SYSTEM_PID ;then
        echo "odenos core system is already running"
        return 1
    fi
    purge_zk_log ${ODENOS_LOG}/log4j2_odenos_system.log
    $JAVA ${ODENOS_OPT} ${ZOOKEEPER_OPT} \
	-Dlog4j.configurationFile=file:${ODENOS_CONF}/log4j2_java.yaml \
	-Dlog4j2_app.log=${ODENOS_LOG}/log4j2_odenos_system.log \
	$ODENOS_MAIN -s -S $MANAGER -o ${REST_PORT} -h ${REST_ROOT} \
	-i $HOST_M -p $PORT_M -I $HOST_B -P $PORT_B -t $TXOFFSET_SYSTEM \
	-m $MONITOR $MONITOR_LOGGING $ZOOKEEPER_HOST $ZOOKEEPER_PORT \
	$ZOOKEEPER_EMBED &
    echo $! > $FILE_ODENOS_SYSTEM_PID
    return 0
}

check_start_system()
{
    local ret_val reply_code cnt

    cnt=0
    while [ ${cnt} -lt ${MAX_WAIT_COUNT} ] ;do
        cnt=$(( cnt + 1 ))
        ret_val=0
	msg="$( curl http://${REST_HOST}:${REST_PORT}/systemmanager/property -w "\n%{response_code}\n" 2>/dev/null )"
	reply_code="$( echo "${msg}" | grep '^[0-5][0-9][0-9]$' )"
	msg="${msg%${reply_code}}" ; msg="$( echo "${msg}" )"
	case "${DEBUG}-${reply_code}" in
	*-200)
	    ;;
	ON-*|on-*|YES-*|yes-*)
	    echo "DEBUG: SystemManager: reply=${reply_code}, msg=<${msg%${reply_code}}>, cnt=${cnt}" >&2
	    ;;
	esac
	case "${reply_code}" in
	200)
	    if [ -n "${MANAGER_ENABLED}" ] ;then
		echo "Started System Manager" >&2
	    else
		echo "Started System Manager on ${REST_HOST}:${REST_PORT}" >&2
	    fi
	    ;;
	000|404)    # 000 is not connected
	    ret_val=10
	    ;;
	*)
	    echo "Failed System Manager: ${reply_code}" >&2
	    ret_val=1
	    break
	    ;;
	esac
	if [ ${ret_val} -eq 10 ] ;then
	    #echo "Starting ODENOS Please wait ...${proc_list}" >&2
	    sleep 1
	else
	    break
	fi
    done

    if [ ${ret_val} -eq 10 ] ;then
	echo "Met Timeout Starting ODENOS" >&2
    fi
    return ${ret_val}
}

stop_system()
{
    if check_pid_file $FILE_ODENOS_SYSTEM_PID ;then
	kill `cat $FILE_ODENOS_SYSTEM_PID`  > /dev/null 2>&1
	sleep 1
    else
	echo "odenos core system is not running"
    fi
    unlink $FILE_ODENOS_SYSTEM_PID > /dev/null 2>&1
}

start_process()
{
    local res proc_list PROC_NAME PROC_TYPE PROC_DIRS idx

    idx=0
    proc_list=""
    while [ ${idx} -lt ${PROC_CNT} ] ;do
        idx=$(( idx + 1 ))
        eval PROC_NAME="\${PROC_NAME_${idx}}"
        eval PROC_TYPE="\${PROC_TYPE_${idx}}"
        eval PROC_DIRS="\${PROC_DIRS_${idx}}"
	PROC_TXOFFSET=`get_txoffset`

	file="$ODENOS_TMP/odenos_${PROC_NAME}.pid"

	if check_pid_file $file ;then
            echo "odenos $PROC_NAME is already running"
            return 1
	fi
	proc_list="${proc_list:+${proc_list} }${PROC_NAME}"

	if [ $PROC_TYPE = "java" ] ;then
	    # start java RemoteObjectManager
	    $JAVA ${ODENOS_OPT} ${ZOOKEEPER_OPT} \
		-Dlog4j.configurationFile=file:${ODENOS_CONF}/log4j2_java.yaml \
		-Dlog4j2_app.log=${ODENOS_LOG}/log4j2_odenos_${PROC_NAME}.log \
		$ODENOS_MAIN -r "${PROC_NAME}" -d "${PROC_DIRS}" \
		-S $MANAGER -i $HOST_M -p $PORT_M -I $HOST_B -P $PORT_B -t $PROC_TXOFFSET \
		-m $MONITOR $MONITOR_LOGGING $ZOOKEEPER_HOST $ZOOKEEPER_PORT &

	    echo $! > $ODENOS_TMP/odenos_${PROC_NAME}.pid

	elif [ $PROC_TYPE = "python" ] ;then
	    # start python RemoteObjectManager
	    PYTHONPATH=${ODENOS_LIB}/python:$PYTHONPATH \
		LOGGING_CONF=${ODENOS_CONF}/log_python.conf \
		APP_LOG=${ODENOS_LOG}/odenos_${PROC_NAME}.log \
		$PYTHON "${ODENOS_MAIN_PY}" \
		-r "${PROC_NAME}" -d "${PROC_DIRS}" -S $MANAGER -i $HOST_M -p $PORT_M -m \
		MONITOR $ZOOKEEPER_HOST $ZOOKEEPER_PORT &

	    echo $! > $ODENOS_TMP/odenos_${PROC_NAME}.pid

	elif [ $PROC_TYPE = "ruby" ] ;then
	    # start ruby RemoteObjectManager
            $TREMA run -d "${ODENOS_MAIN_RB} --cmpmgr=${PROC_NAME}"
	fi

	if [ $(( idx + 1 )) -lt ${PROC_CNT} ] ;then
	    sleep 1
	fi

    done

    check_start_process ${proc_list}
    res=$?
    if [ ${res} -ne 0 ] ;then
	return 1
    fi
    return 0
}

check_start_process()
{
    local ret_val proc_list proc msg reply_code cnt

    proc_list=" $* "
    cnt=0
    while [ -n "${proc_list% }" -a ${cnt} -lt ${MAX_WAIT_COUNT} ] ;do
	cnt=$(( cnt + 1 ))
	ret_val=0
	for proc in ${proc_list} ;do
	    msg="$( curl http://${REST_HOST}:${REST_PORT}/systemmanager/component_managers/${proc} -w "\n%{response_code}\n" 2>/dev/null )"
	    reply_code="$( echo "${msg}" | grep '^[0-5][0-9][0-9]$' )"
	    msg="${msg%${reply_code}}" ; msg="$( echo "${msg}" )"
	    case "${DEBUG}-${reply_code}" in
	    *-200)
		;;
	    ON-*|on-*|YES-*|yes-*)
		echo "DEBUG: ${proc}: reply=${reply_code}, msg=<${msg%${reply_code}}>, cnt=${cnt}" >&2
		;;
	    esac
	    case "${reply_code}" in
	    200)
		echo "Started Compnent Manager :: ${proc}" >&2
		proc_list="${proc_list% ${proc} *} ${proc_list#* ${proc} }"
		;;
	    000|404)	# 000 is not connected
		ret_val=10
		;;
	    *)
		echo "Failed Compnent Manager :: ${proc}: ${reply_code}" >&2
		ret_val=1
		break
		;;
	    esac
	done
	if [ ${ret_val} -eq 10 ] ;then
	    #echo "Starting ODENOS Please wait ...${proc_list}" >&2
	    sleep 1
	elif [ ${ret_val} -ne 0 ] ;then
	    break
	fi
    done

    if [ ${ret_val} -eq 10 ] ;then
	echo "Met Timeout Starting ODENOS" >&2
    fi
    return ${ret_val}
}

stop_process()
{
    local PROC_NAME PROC_TYPE PROC_DIRS idx file

    idx=0
    while [ ${idx} -lt ${PROC_CNT} ] ;do
        idx=$(( idx + 1 ))
        eval PROC_NAME="\${PROC_NAME_${idx}}"
        eval PROC_TYPE="\${PROC_TYPE_${idx}}"
        eval PROC_DIRS="\${PROC_DIRS_${idx}}"

	case "${PROC_TYPE}" in
	java|python)
	    file=$ODENOS_TMP/odenos_${PROC_NAME}.pid
	    if check_pid_file ${file} ;then
		kill `cat ${file}`  > /dev/null 2>&1
	    else
		echo "odenos $PROC_NAME is not running"
	    fi
	    unlink ${file} > /dev/null 2>&1
            ;;
	ruby)
	    file="${TREMA%/trema}/tmp/pid/switch_manager.pid"
	    if ! check_pid_file ${file} ;then
		echo "odenos $PROC_NAME is not running"
	    fi
	    $TREMA killall
	    ;;
	esac

    done

    sleep 1
    return 0
}

start()
{
    local res
    echo "--  ----------------------------------> "
    echo "--   o-o  o-o   o--o o   o  o-o   o-o   "
    echo "--  o   o |  \  |    |\  | o   o |      "
    echo "--  |   | |   O O-o  | \ | |   |  o-o   "
    echo "--  o   o |  /  |    |  \| o   o     |  "
    echo "--   o-o  o-o   o--o o   o  o-o  o--o   "
    echo "--                                      "
    echo ""
    echo "starting ODENOS"
    read_config_file

    set_classpath

    if [ ! -d "${ODENOS_LOG}" ] ;then
        mkdir -p "${ODENOS_LOG}"
    fi
    if [ ! -d "${ODENOS_TMP}" ] ;then
        mkdir -p "${ODENOS_TMP}"
    fi
    if [ -n "${MANAGER_ENABLED}" ] ;then
        start_system
    fi
    check_start_system
    res=$?
    if [ ${res} -ne 0 ] ;then
	return 1
    fi

    start_process
    res=$?
    if [ ${res} -ne 0 ] ;then
	echo "ODENOS Start-up failed!" >&2
	return 1
    else
	echo "ODENOS Start-up completion." >&2
	return 0
    fi
}

stop()
{
    echo "stop ODENOS" >&2
    read_config_file

    stop_process
    if [ -n "${MANAGER_ENABLED}" ] ;then
        stop_system
    fi
    return 0
}

status()
{
    local res PROC_NAME PROC_TYPE PROC_DIRS idx

    read_config_file

    if [ -n "${MANAGER_ENABLED}" ] ;then
	if check_pid_file $FILE_ODENOS_SYSTEM_PID ;then
	    echo "odenos core system is running"
	else
	    echo "odenos core system is not running"
	fi
    fi

    idx=0
    while [ ${idx} -lt ${PROC_CNT} ] ;do
	idx=$(( idx + 1 ))
	eval PROC_NAME="\${PROC_NAME_${idx}}"
	eval PROC_TYPE="\${PROC_TYPE_${idx}}"
	eval PROC_DIRS="\${PROC_DIRS_${idx}}"

	case "${PROC_TYPE}" in
	java|python)
	    file="$ODENOS_TMP/odenos_${PROC_NAME}.pid"
            ;;
	ruby)
	    file="${TREMA%/trema}/tmp/pid/switch_manager.pid"
	    ;;
	esac
	if check_pid_file ${file} ;then
	    echo "odenos $PROC_NAME is running"
	else
	    echo "odenos $PROC_NAME is not running"
	fi
    done
    return 0
}

set_conf()
{
  if [ $# = 3 ] ;then
    case "$2" in
    -c)
      echo "Read config files :: $3" >&2
      ODENOS_CONF_FILE=$3
    esac
  fi
}

show_help()
{
    echo >&2 "usage : $0 [start|stop|restart|status]"
    echo >&2 ">$0 start     (./etc/odenos.conf is loaded by default.)"
    echo >&2 ">$0 start -c [FILE]     (loaded original config file.)"
}

set_conf "$@"
case "$1" in
start)
    start
    ;;
stop)
    stop
    ;;
status)
    status
    ;;
restart)
    stop
    start
    ;;
*)
    show_help
    ;;
esac

cd ${RUN_DIR}