#!/bin/bash
${TraceF}

#
# Init file for Backup Agent
#
# chkconfig: 235 95 05
# description: Backup Agent
#
# processname: VVAgent

_platform_init() { #{{{1
  . /etc/rc.d/init.d/functions
}

_start_agent_daemon() { #{{{1
  running=`_test_running "${1}"`

  if [ ${running} -eq 0 ]; then #{{{
    pid=`_running_pid "${1}"`
    _agent_daemon_is_running ${?} "${1}" ${pid}
    return
  fi #}}}

  _display_partial "Starting ${1}:"

  save_cwd=`pwd`
  cd "${agentDir}"

  case `basename ${1}` in #{{{
    VVAgent)  _start_vvagent
              RETVAL=${?} ;;
    buagent)  _start_buagent
              RETVAL=${?} ;;
    *)        RETVAL=999 ;;
  esac #}}}

  cd "${save_cwd}"

  if [ ${RETVAL} -eq 0 ]; then #{{{
    sleep 1
    running=`_test_running "${1}"`
    if [ ${running} -ne 0 ]; then #{{{
      RETVAL=1
    else
      RETVAL=0
    fi #}}}
  else
    [ -n "${2}" -a -f "${2}" ] && logger -f "${2}"
  fi #}}}

  if [ ${RETVAL} -eq 0 ]; then #{{{
    [ ${quiet} -eq 0 ] && success "${1} (`_running_pid "${1}"`) startup"
  else
    [ ${quiet} -eq 0 ] && failure "${1} startup"
  fi #}}}

  _display_message
} #}}}1

# vim: ft=sh foldmethod=marker


# Initialization {{{1
_type() { #{{{2
  type ${1} 1> /dev/null 2> /dev/null
}

_init_this_script() { #{{{2
agentDir="/opt/BUAgent"
  runDir=/var/run/buagent
  vvlog="${agentDir}/vvlog"
  bulog="${agentDir}/bulog"
  vvagent="${agentDir}/VVAgent"
  buagent="${agentDir}/buagent"
  vvagentpid=${runDir}/VVAgent.pid
  buagentpid=${runDir}/BUAgent.pid
  quiet=0
  [ ! -z "${2}" -a "${2}" = "quiet" ] && quiet=1

  has_buagent=0
  [ -f "${agentDir}/buagent.cfg" ] && has_buagent=1
  [ ! -z "${BUAGENT_CMDLINE}" ] && has_buagent=1
  [ ! -x "${buagent}" ] && has_buagent=0

  _platform_init

  [ -d ${runDir} ] || mkdir -p ${runDir}

  RETVAL=0
}

# Messages {{{1
_type _usage || _usage() { #{{{2
  _display_message "Usage: ${0} { start | stop | restart | status }"
}
_display_partial() { #{{{2
  [ ${quiet} -eq 0 ] && printf "${@}"
}

_display_message() { #{{{2
  [ ${quiet} -eq 0 ] && echo ${*}
}

_agent_start_failed() { #{{{2
  _display_message "${1} failed to start."
}

# Process Management {{{1
_type _test_running || _test_running() { #{{{2
  # Daemons return 1 if not running, and 0 if running
  case `basename "${1}"` in #{{{
    VVAgent)  "${vvagent}" -S > /dev/null 2>&1 
              RC=${?} ;;
    buagent)  "${buagent}" --status > /dev/null 2>&1 
              RC=${?} ;;
    *)        RC=1 ;;
  esac #}}}
  echo ${RC}
  return ${RC}
} 

_type _running_pid || _running_pid() { #{{{2
  running=`_test_running "${1}"`
  result=${?}
  case `basename "${1}"` in #{{{
    VVAgent)  [ -f "${vvagentpid}" ] && cat "${vvagentpid}" || echo 0 ;;
    buagent)  [ -f "${buagentpid}" ] && cat "${buagentpid}" || echo 0 ;;
    *)        echo 0 ;;
  esac #}}}
  return ${result}
}

# VVAgent Management {{{1
_type _vvagent_cmd || _vvagent_cmd() { #{{{2
  "${vvagent}" "${@}" >> "${vvlog}" 2>> "${vvlog}"
}

_type _start_vvagent || _start_vvagent() { #{{{2
  _vvagent_cmd -d -p "${agentDir}"
}

_type _stop_vvagent || _stop_vvagent() { #{{{2
  _vvagent_cmd -s
} 

_type _kill_vvagent || _kill_vvagent() { #{{{2
  _vvagent_cmd -k
} 

# BUAgent Management {{{1
_type _buagent_cmd || _buagent_cmd() { #{{{2
  "${buagent}" "${@}" >> "${bulog}" 2>> "${bulog}"
}

_type _start_buagent || _start_buagent() { #{{{2
  [ -z "${BUAGENT_CMDLINE}" ] && BUAGENT_CMDLINE="--path \"${agentDir}\""
  _buagent_cmd "${BUAGENT_CMDLINE}"
} 

_type _stop_buagent || _stop_buagent() { #{{{2
  _buagent_cmd --stop
} 

_type _kill_buagent || _kill_buagent() { #{{{2
  _buagent_cmd --kill
} 

# Daemon Management Wrappers {{{1
_type _agent_daemon_is_running || _agent_daemon_is_running() { #{{{2
  prog=`basename "${2}"`
  if [ "${1}" -eq 0 ]; then
    _display_message "${prog} is running (PID ${3})."
    return 0
  else
    _display_message "${prog} is not running."
    return 1
  fi
}

_type _status_agent || _status_agent() { #{{{2
  executable="${1}"
  pid=`_running_pid "${executable}"`
  agent_is_running=${?}
  _agent_daemon_is_running ${agent_is_running} "${executable}" ${pid}
  RETVAL=`expr ${RETVAL} + ${?}`
}

_type _start_agent_daemon || _start_agent_daemon() { #{{{2
  running=`_test_running ${1}`

  if [ ${running} -eq 0 ]; then #{{{
    pid=`_running_pid "${1}"`
    _agent_daemon_is_running ${?} "${1}" ${pid}
    return `expr ${RETVAL} + ${?}`
  fi #}}}

  _display_partial "Starting ${1}... "

  save_cwd=`pwd`
  cd "${agentDir}"

  case `basename "${1}"` in #{{{
    VVAgent)  _start_vvagent
              RETVAL=${?} ;;
    buagent)  _start_buagent
              RETVAL=${?} ;;
    *)        RETVAL=999 ;;
  esac #}}}

  cd "${save_cwd}"

  [ ${RETVAL} -ne 0 ] && _agent_start_failed ${1}

  sleep 1
  running=`_test_running "${1}"`
  # running=1 if agent is not running
  [ ${running} -ne 0 ] && _agent_start_failed ${1} || _display_message started.
}

_type _stop_agent_daemon || _stop_agent_daemon() { #{{{2
  running=`_test_running "${1}"`

  if [ ${running} -eq 1 ]; then #{{{
    pid=`_running_pid "${1}"`
    _agent_daemon_is_running ${?} "${1}" ${pid}
    return `expr ${RETVAL} + ${?}`
  fi #}}}

  _display_partial "Stopping ${1}... "

  save_cwd=`pwd`
  cd "${agentDir}"

  case `basename ${1}` in #{{{
    VVAgent)  _stop_vvagent
              RETVAL=${?} ;;
    buagent)  _stop_buagent
              RETVAL=${?} ;;
    *)        RETVAL=999 ;;
  esac #}}}

  cd "${save_cwd}"

  # It can take up to 10 seconds for an Agent daemon to shutdown
  retry=5
  running=`_test_running "${1}"`
  while [ ${retry} -gt 0 -a ${running} -eq 0 ]; do #{{{
    sleep 2
    retry=`expr ${retry} - 1`
    running=`_test_running "${1}"`
  done #}}}

  # Make sure the agent died and kill it if it is taking too long
  running=`_test_running "${1}"`
  if [ ${running} -eq 0 ]; then
    case `basename ${1}` in #{{{
      VVAgent)  _kill_vvagent
                RETVAL=${?} ;;
      buagent)  _kill_buagent
                RETVAL=${?} ;;
      *)        RETVAL=999 ;;
    esac #}}}
  fi
    
  _display_message stopped.
}

_type _kill_agent_daemon || _kill_agent_daemon() { #{{{2
  running=`_test_running "${1}"`

  if [ ${running} -eq 1 ]; then #{{{
    pid=`_running_pid "${1}"`
    _agent_daemon_is_running ${?} "${1}" ${pid}
    return `expr ${RETVAL} + ${?}`
  fi #}}}

  _display_partial "Killing ${1}... "

  save_cwd=`pwd`
  cd "${agentDir}"

  case `basename ${1}` in #{{{
    VVAgent)  _kill_vvagent
              RETVAL=${?} ;;
    buagent)  _kill_buagent
              RETVAL=${?} ;;
    *)        RETVAL=999 ;;
  esac #}}}

  cd "${save_cwd}"

  _display_message killed.
}

_type _start_agent || _start_agent() { #{{{2
  _start_agent_daemon VVAgent "${vvlog}"
  [ ${has_buagent} -eq 1 ] && _start_agent_daemon buagent "${bulog}"
}

_type _stop_agent || _stop_agent() { #{{{2
  _stop_agent_daemon VVAgent
  [ ${has_buagent} -eq 1 ] && _stop_agent_daemon buagent
}

_type _kill_agent || _kill_agent() { #{{{2
  _kill_agent_daemon VVAgent
  [ ${has_buagent} -eq 1 ] && _kill_agent_daemon buagent
}

# Default Implementations #{{{1
_type _platform_init || _platform_init() { #{{{2
  LD_LIBRARY_PATH="${agentDir}:${LD_LIBRARY_PATH}"
  export LD_LIBRARY_PATH
}

_type _platform_exit || _platform_exit() { #{{{2
  exit "${@}"
}

_type _platform_action || _platform_action() { #{{{2
  # No platform actions by default. Return 0 if the platform action completes
  # normally.
  return 1
}

_type svc_start || svc_start() { #{{{2
  _start_agent
}

_type svc_stop || svc_stop() { #{{{2
  _stop_agent
}

_type svc_kill || svc_kill() { #{{{2
  _kill_agent
}

_type svc_status || svc_status() { #{{{2
  _status_agent "${vvagent}"
  if [ ${has_buagent} -eq 1 ]; then
     _status_agent "${buagent}"
  fi
}

_type svc_restart || svc_restart() { #{{{2
  svc_stop
  sleep 3
  svc_start
}

# Execution {{{1
_delegate_action() { #{{{2
  _platform_action ${1}

  [ ${?} -eq 0 ] && return

  case "${1}" in #{{{
    start)          svc_start ;;
    stop)           svc_stop ;;
    kill)           svc_kill ;;
    restart)        svc_restart ;;
    status)         svc_status ;;
    *-all)          has_buagent=1
                    case "${1}" in #{{{
                      start*)   svc_start ;;
                      stop*)    svc_stop ;;
                      kill*)    svc_kill ;;
                      restart*) svc_restart ;;
                      status*)  svc_status ;;
                      *)        _usage
                                exit 1 ;;
                    esac #}}}
                    ;;
    *)              _usage
                    exit 1 ;;
  esac #}}}

  _platform_exit ${RETVAL}
}

_init_this_script "${@}"
_delegate_action "${@}"


# vim:foldmethod=marker