Histórico da Página

#!/bin/bash
#description: Starts and stops

#########################################
#	CONFIGURACAO DO SERVICO		#
#########################################
#Inserir o nome do executavel 
prog="appsrvlinux_broker"

## Configuração do tipo de balance:
    # broker_type="balance_smart_client_desktop"
    # broker_type="balance_http"
    # broker_type="balance_telnet"
    # broker_type="balance_web_services"

broker_type="balance_smart_client_desktop"

#Inserir o caminho do diretorio do executavel
pathbin="/totvs/protheus/bin/protheus_broker"

alias=$(basename "${pathbin}")

progbin="${pathbin}/${prog}"
pidfile="/var/run/${alias}.pid"
lockfile="/var/lock/subsys/${alias}"

log_filename=console.log
#O appserver.ini do broker dever ter o mesmo nome do executável.
config_filename=${prog}.ini
#################################################################
#Configuracao de ULIMIT
#################################################################
#open files - (-n)
openFiles=65536
#stack size - (kbytes, -s)
stackSize=1024
#core file size - (blocks, -c)
coreFileSize=unlimited
#file size - (blocks, -f)
fileSize=unlimited
#cpu time - (seconds, -t)
cpuTime=unlimited
#virtual memory - (-v)
virtualMemory=unlimited

#################################
#	FIM DA CONFIGURACAO	#
#################################

RETVAL=0

## Verifica se o executavel tem permissao correta e se esta acessivel
test -x $progbin || { echo "$progbin not installed";
        if [ "$1" = "stop" ]; then exit 0;
        else exit 5; fi; }

#Prepara as ulimit para o servico do DBAccess
ulimit -n ${openFiles}
ulimit -s ${stackSize}
ulimit -c ${coreFileSize}
ulimit -f ${fileSize}
ulimit -t ${cpuTime}
ulimit -v ${virtualMemory}

#Acessa o diretorio configurado na variavel PATHBIN
cd $pathbin

#Variaveis de Output
red="\033[31m"
green='\033[32m'
reset='\033[m'

export LD_LIBRARY_PATH=${pathbin}

## Start_service: função que inicia o serviço.
start_service() {

if [ -z `pidof -x $progbin` ] ; then
   echo "Starting $prog... "
   ${progbin} -daemon -${broker_type} -a >/dev/null &
   RETVAL=$?
   if [ ${RETVAL} -eq 0 ]; then
      touch ${lockfile}
      touch ${pidfile}
      pidof -x ${progbin} > ${pidfile}
      sleep 1
      echo "PID : " `cat ${pidfile}`
      echo -e "${prog} running :   ${green}[ OK ]${reset}"
   else
      echo -e "Failed to start ${prog} :         ${red}[ Failure ]${reset}"
   fi 
   echo
else
   echo -e "$prog is ${green}Started${reset} pid `pidof -x $progbin`"
fi
}

## Stop_service: função que encerra o serviço.
stop_service() {
if [ ! -z `pidof -x ${progbin}` ] ; then

   ./${progbin} -${broker_type} -o

   echo
   rm -f $lockfile
   rm -f $pidfile
   echo -n "Stopping ${prog}."
   while [ ! -z `pidof -x ${progbin}` ]
   do
        echo -n "."
        sleep 1
   done
   echo
   echo -e "${prog} is Stopped     ${red}[ Stopped ]${reset}"
else
   echo -e "${prog} is not running ${red}[ Stopped ]${reset}"
fi
}

## Kill_service: função que interrompe o serviço.
kill_service() {
if [ ! -z `pidof -x ${progbin}` ] ; then

   kill -s SIGKILL $(pidof -x ${progbin})

   echo
   rm -f $lockfile
   rm -f $pidfile
   echo -n "Stopping ${prog}."
   while [ ! -z `pidof -x ${progbin}` ]
   do
        echo -n "."
        sleep 1
   done
   echo
   echo -e "${prog} is Killed     ${red}[ Killed ]${reset}"
else
   echo -e "${prog} is not running ${red}[ Stopped ]${reset}"
fi
}

## get_stats: função que coleta os dados do serviço e exporta no contexto atual.
get_stats() {
date 
echo
if [ ! -z `pidof -x ${progbin}` ] ; then
    export pid=$(pidof -x ${progbin})

    export progport=$(lsof -Pp ${pid} | grep '(LISTEN)' | awk '{ print $9}' | cut -d: -f2 | xargs | tr ' ' ',')

    export list=$(ps -eo pid,start_time,cputime,pcpu,pmem,stat,size,nlwp,comm | grep ${pid})

    export start_time=$(echo -e $list | awk '{ print $2 }')
    export cputime=$(echo -e $list | awk '{ print $3 }')
    export pcpu=$(echo -e $list | awk '{ print $4 }')
    export pmem=$(echo -e $list | awk '{ print $5 }')
    export stat=$(echo -e $list | awk '{ print $6 }')
    export size=$(echo -e $list | awk '{ print $7 }')
    export nlwp=$(echo -e $list | awk '{ print $8 }')
    export comm=$(echo -e $list | awk '{ print $9 }')

    export size=$(echo -e "$(bc <<< "scale=2;$size/1024")MB")
else
    echo -e "Status process: ${red} [ Stopped ] ${reset} "
    echo -e "${red}- Program $prog is not running! ${reset}"
fi
}

## Status: função que exibe o estado atual do serviço em formato de tabela.
status() {
get_stats

output=$(cat << EOF
ALIAS PROCESS PORT PID CPU_TIME %CPU %MEM MEMORY THREADS STATUS PATH
${alias} ${comm} ${progport} ${pid} ${cputime} ${pcpu} ${pmem} ${size} ${nlwp} ${green}[running]${reset} ${progbin} 
EOF
)

echo -e "$output" | column -t
}

get_log() {
    consolelog=$(grep -i '^\s*consolefile\s*=' "${pathbin}/${config_filename}" | awk -F= '{print $2}' | tr -d ' ')
    if [ ! -n "$consolelog" ]; then
        if [ -n "${pathbin}/${log_filename}" ]; then
            consolelog="${pathbin}/${log_filename}"
        else
            echo '${red}Logfile not found!${reset} : "${pathbin}/${log_filename}"'
            echo 'Config File: ${pathbin}/${config_filename}'
            echo 'Add parameter: consolefile=${pathbin}/${log_filename}'
        fi
    fi
    echo ${consolelog}
}

## Describe: função que exibe as configurações do ambiente onde o servico está rodando.
describe() {
get_stats

## Exibe o status atual do serviço caso ele esteja em execução.
if [ ! -z `pidof -x ${progbin}` ] ; then
    output=$(cat << EOF
AlIAS ${alias}
PROCESS ${comm}
PATH ${progbin}
PORT ${progport}
PID ${pid}
STARTED ${start_time}
TIME ${cputime}
%CPU ${pcpu}
%MEM ${pmem}
MEMORY ${size}
STATUS [Running]
THREADS ${nlwp}
EOF
)
echo -e "$output" | column -t
echo
fi

## Exibe as bibliotecas utilizadas pelo serviço.
echo "### LIBRARY ####"
ldd ${progbin}
echo ""

## Exibe o appserver.ini completo quando localizado.
echo "### INI ###"
if [ -n "${pathbin}/${config_filename}" ]; then
    echo ""
    echo -e "${config_filename} : ${green} ${pathbin}/${config_filename} ${reset}"
    echo ""
    cat ${pathbin}/${config_filename}
else
    echo "O appserver não foi localizado."
fi
echo ""

## Exibe as 15 primeiras linhas e as 15 ultimas linhas do logfile.
echo "### LOGFILE ###"
consolelog=$(get_log)

if [ -n "$consolelog" ]; then
    echo ""
    echo -e "console.log : ${green} ${consolelog} ${reset}"
    echo ""
    head -n 15 "$consolelog"
    echo ...
    tail -n 15 "$consolelog"
else
    echo "Chave 'consolefile' não encontrada no arquivo ${pathbin}/${config_filename}."
fi

}

## Tail_log: Executa o comando tail -f no arquivo de log do serviço.
tail_log() {
consolelog=$(get_log)

if [ -n "$consolelog" ]; then
    echo ""
    echo -e "console.log : ${green}$consolelog${reset}"
    echo ""
    head -n 15 "$consolelog"
    echo ...
    tail -f -n 15 "$consolelog"
else
    echo "Chave 'consolefile' não encontrada no arquivo ${pathbin}/${config_filename}."
fi
}

## Export_service: Exporta as configurações do ambiente onde o serviço sendo executado junto com o logfile.
export_service() {

describe > /tmp/${SCRIPT_NAME}_describe.txt

ldd -v ${progbin} > /tmp/${SCRIPT_NAME}_library.txt

consolelog=$(get_log)
if [ -n "$consolelog" ]; then
    cp -p $consolelog /tmp/${SCRIPT_NAME}_console.log
else
    echo "Chave 'consolefile' não encontrada no arquivo ${pathbin}/${config_filename}."
fi

if [ -n "${pathbin}/${config_filename}" ]; then
    cp -p ${pathbin}/${config_filename} /tmp/${SCRIPT_NAME}_${config_filename}
else
    echo "O appserver não foi localizado."
fi

zip_file="/tmp/${SCRIPT_NAME}_export.zip"
cd /tmp
zip -r "$zip_file" "${SCRIPT_NAME}_describe.txt" "${SCRIPT_NAME}_console.log" "${SCRIPT_NAME}_${config_filename}" "${SCRIPT_NAME}_library.txt"

if [ -f "$zip_file" ]; then
    echo -e "Pacote criado com sucesso: ${green} $zip_file ${reset}"
else
    echo -e "${red}$ Erro ao criar o pacote .zip ${reset}"
fi
rm -f /tmp/${SCRIPT_NAME}_describe.txt /tmp/${SCRIPT_NAME}_console.log /tmp/${SCRIPT_NAME}_${config_filename} /tmp/${SCRIPT_NAME}_library.txt

}

SCRIPT_NAME=$(basename "$0")

## Link: cria o link simbolico com o nome do serviço configurado neste script e 
## renomeia o appserver.ini para o mesmo nome do programa configurado. Configuração necessária apenas para o serviço do broker.
link() {
if [ -e $progbin ] ; then
   echo "Appserver symbolic link "
   echo
else
   ln -s ${pathbin}/appsrvlinux $progbin
   echo "$progbin created symbolic link"
   cp -p ${pathbin}/appserver.ini $progbin.ini
   echo "Copy ${pathbin}/appserver.ini to ${progbin}.ini"
fi
}

## Show_help: Mensagem de ajuda para usar este script.
show_help() {
    cat << EOF
Usage: ${SCRIPT_NAME} {start|stop|kill|restart|status|describe|export|log}

Gerenciamento de serviços permite iniciar, parar, reiniciar, matar, verificar o status, exibir informações. 
Use as opções start|stop|kill|restart|status|describe|export|log para realizar operações comuns de serviço com facilidade.

  start     : Inicia o serviço.
  stop      : Encerra o serviço.
  kill      : Encerra o serviço de forma abrupta.
  restart   : Reinicia o serviço.
  status    : Exibe os detalhes do serviço em formato de tabela.
  describe  : Exibe os detalhes do serviço e configurações.
  export    : Exporta as informações do describe junto com o ${config_filename} e console.log para 
              o arquivo ${SCRIPT_NAME}.zip em /tmp.
  log       : Exibe o log com o comando tail -f.

EOF
}

#MAIN
case "$1" in
start)
    start_service 2>/dev/null
    ;;
stop)
    stop_service
    ;;
kill)
    kill_service
    ;;
restart)
    stop_service
    sleep 1
    start_service 2>/dev/null
    sleep 1
    status
    exit $?
    ;;
status)
    if [ ! -z `pidof -x $progbin` ] ; then
       status
    else
        echo -e "Status process: ${red} [ Stoppe ] ${reset} "
        echo -e "${red}- Program $prog is not running! ${reset}"
    fi
    ;;
describe)
    describe
    ;;
log)
    tail_log
    ;;
link)
    link
    ;;
export)
    export_service
    ;;
*)
    show_help
    exit 1
esac

exit 0