# Copyright 1999-2015 Gentoo Foundation

# Copyright 1999-2014 Gentoo Foundation

# $Header: /var/cvsroot/gentoo-x86/app-emulation/lxc/files/lxc.initd.3,v 1.2 2015/04/23 16:31:44 hwoarang Exp $

# $Header: $

name="Linux Container ${CONTAINER}"

LXC_PATH="/var/lib"

extra_commands="info halt unfreeze"

extra_started_commands="freeze attach"

lxc_get_configfile() {

	if [ -f "${LXC_PATH}/${CONTAINER}.conf" ]; then

description="Service to start Linux Container"

		echo "${LXC_PATH}/${CONTAINER}.conf"

description_info="Get info about container"

	elif [ -f "${LXC_PATH}/${CONTAINER}/config" ]; then

description_halt="Forse to killing container"

		echo "${LXC_PATH}/${CONTAINER}/config"

description_freeze="Freeze running container"

	else

description_unfreeze="Unfreeze freezed container"

		eerror "Unable to find a suitable configuration file."

description_attach="Start a shell inside a running container"

		eerror "If you set up the container in a non-standard"

		eerror "location, please set the CONFIGFILE variable."

## if necessary, you can manually set the value of these variables in the /etc/rc.conf or /etc/conf.d/lxc

		return 1

## be sure when you change this variables

	fi

: ${rc_lxc__cgrouppath:=/sys/fs/cgroup/*/lxc}

}

# to avoid situation like as this https://bugs.gentoo.org/show_bug.cgi?id=416643

if [[ -z "${rc_lxc__lxcpath}" ]]; then

[ $CONTAINER != $SVCNAME ] && CONFIGFILE=${CONFIGFILE:-$(lxc_get_configfile)}

    rc_lxc__lxcpath=$(lxc-config lxc.lxcpath)

    _name="--name '${CONTAINER}'"

lxc_get_var() {

else

	awk 'BEGIN { FS="[ \t]*=[ \t]*" } $1 == "'$1'" { print $2; exit }' ${CONFIGFILE}

    _name="--name '${CONTAINER}' --lxcpath '${rc_lxc__lxcpath}'"

}

fi

if [[ "${SVCNAME}" = "${CONTAINER}" ]]; then

    CONFIGFILE=""

elif [ -f "${rc_lxc__lxcpath}/${CONTAINER}.conf" ]; then

    CONFIGFILE="${rc_lxc__lxcpath}/${CONTAINER}.conf"

else

    CONFIGFILE="${rc_lxc__lxcpath}/${CONTAINER}/config"

fi

required_files=${CONFIGFILE}

eval pidfile="\${rc_${SVCNAME//./_}__pidfile:-/run/lxc/\${CONTAINER}.pid}"

eval logfile="\${rc_${SVCNAME//./_}__logfile:-/var/log/lxc/\${CONTAINER}.log}"

eval logpriority="\${rc_${SVCNAME//./_}__logpriority:-\${rc_lxc__logpriority:-WARN}}"

eval CONSOLELOG="\$rc_${SVCNAME//./_}__consolelog"

eval linuxrc="\$rc_${SVCNAME//./_}__linuxrc"

command_args="${_name} --rcfile '${CONFIGFILE}' --logfile '${logfile}' --logpriority '${logpriority}'"

if [[ -z "${linuxrc}" ]]; then

    command="/usr/sbin/lxc-start"

    command_args+=" --pidfile '${pidfile}' --daemon${CONSOLELOG:+ --console-log '${CONSOLELOG}'}"

else

    [[ -n "${CONSOLELOG}" ]] && start_stop_daemon_args+=" --stdout '${CONSOLELOG}' --stderr '${CONSOLELOG}'"

    command_background="yes"

    command="/usr/sbin/lxc-execute"

    command_args+=" -- ${linuxrc}"

fi

	awk 'BEGIN { FS="[ \t]*=[ \t]*"; _link=""; _type="" }

    awk 'BEGIN { FS="[ \t]*=[ \t]*"; _link=""; _type="" }

		$1 == "lxc.network.type" {_type=$2;}

        $1 == "lxc.network.type" {_type=$2;}

		$1 == "lxc.network.link" {_link=$2;}

        $1 == "lxc.network.link" {_link=$2;}

		{if(_link != "" && _type != ""){

        {if(_link != "" && _type != ""){

			printf("%s:%s\n", _link, _type );

            printf("%s:%s\n", _link, _type );

			_link=""; _type="";

            _link=""; _type="";

		}; }' <${CONFIGFILE}

        }; }' < "${CONFIGFILE}"

	if [ ${CONTAINER} = ${SVCNAME} ]; then

    if [[ "${SVCNAME}" = "${CONTAINER}" ]]; then

		eerror "You have to create an init script for each container:"

        eerror "You have to create an init script for each container:"

		eerror " ln -s lxc /etc/init.d/lxc.container"

        eerror " ln -s lxc /etc/init.d/lxc.container"

		return 1

        return 1

	fi

    fi

    local _ret=0

	# no need to output anything, the function takes care of that.

    ## protection against bad SVCNAME

	[ -z "${CONFIGFILE}" ] && return 1

    ## Since ${SVCNAME//./_} may be used in some rc_.. environment, names must be correct

    if [[ -n "${SVCNAME//[0-9A-Za-z.]/}"  ]]; then

	utsname=$(lxc_get_var lxc.utsname)

        eerror "Bad service name '${SVCNAME}'"

	if [ ${CONTAINER} != ${utsname} ]; then

        eerror "You can not use dashes in service name"

	    eerror "You should use the same name for the service and the"

        _ret=1

	    eerror "container. Right now the container is called ${utsname}"

    fi

	    return 1

    if [[ "${SVCNAME//_/}" != "${SVCNAME}" ]]; then

	fi

        ewarn "This is a bad idea to use underline in the name of container service"

        ewarn "Some environments may conflict with services like as '${SVCNAME//_/.}'"

    fi

    return $_ret

	# be quiet, since we have to run depend() also for the

    checkconfig &>/dev/null || return 0

	# non-muxed init script, unfortunately.

    config "${CONFIGFILE}"

	checkconfig 2>/dev/null || return 0

    need localmount

    local _x _if

	config ${CONFIGFILE}

    for _x in $(lxc_get_net_link_type); do

	need localmount

        _if=${_x%:*}

        case "${_x##*:}" in

	local _x _if

            # when the network type is set to phys, we can make use of a

	for _x in $(lxc_get_net_link_type); do

            # network service (for instance to set it up before we disable

		_if=${_x%:*}

            # the net_admin capability), but we might also not set it up

		case "${_x##*:}" in

            # at all on the host and leave the net_admin capable service

			# when the network type is set to phys, we can make use of a

            # to take care of it.

			# network service (for instance to set it up before we disable

            phys)	use net.${_if} ;;

			# the net_admin capability), but we might also not set it up

            *)	need net.${_if} ;;

			# at all on the host and leave the net_admin capable service

        esac

			# to take care of it.

    done

			phys)	use net.${_if} ;;

}

			*)	need net.${_if} ;;

		esac

start_pre() {

	done

    checkconfig || return 1

}

    if eval lxc-info ${_name} 2>/dev/null| grep -qiE '^state:\s+stopped$'; then

        local _c _p=

start() {

        for _c in ${rc_lxc__cgrouppath}/"${CONTAINER}"; do

	checkconfig || return 1

            [ -e "$_c" ] && \

	rm /var/log/lxc/${CONTAINER}.log

                _p="$_p '$_c'" && \

                eerror "Found '$_c'. Perhaps the last time the container '${CONTAINER}' was completed with an error."

	rootpath=$(lxc_get_var lxc.rootfs)

        done

        [ -z "$_p" ] && \

	# Check the format of our init and the chroot's init, to see

            checkpath -q -d "$(dirname "${pidfile}")" && \

	# if we have to use linux32 or linux64; always use setarch

            return 0

	# when required, as that makes it easier to deal with

        ewarn "Possibly for you can help comand: rmdir${_p}"

	# x32-based containers.

        return 1

	case $(scanelf -BF '%a#f' ${rootpath}/sbin/init) in

    else

		EM_X86_64)	setarch=linux64;;

        if eval lxc-info ${_name} 2>/dev/null | grep -qie '^state:'; then

		EM_386)		setarch=linux32;;

            eerror "Can't start ${name}. It's not sopped."

	esac

        else

            eerror "Can't start ${name}. It's not found."

	ebegin "Starting ${CONTAINER}"

        fi

	env -i ${setarch} $(type -p lxc-start) -l WARN -n ${CONTAINER} -f ${CONFIGFILE} -d -o /var/log/lxc/${CONTAINER}.log

    fi

	sleep 0.5

}

	# lxc-start -d will _always_ report a correct startup, even if it

start_post() {

	# failed, so rather than trust that, check that the cgroup exists.

    ebegin "Try to make sure ${name} started correctly"

	[ -d /sys/fs/cgroup/cpuset/lxc/${CONTAINER} ]

    eval lxc-wait ${_name} -s RUNNING -t 15

	eend $?

    eend $?

}

_halt(){

    eval local HALT_TIMEOUT=\${rc_${SVCNAME//./_}__halt_timeout-${rc_lxc__halt_timeout-15}}

    ebegin "Halting ${name}"

    ( eval lxc-stop ${_name} --kill --nowait & ) &>/dev/null

    eval lxc-wait ${_name} -s STOPPED '${HALT_TIMEOUT:+-t ${HALT_TIMEOUT}}'

    if eend $? "Some error on halting ${name}"; then

        mark_service_stopped "${SVCNAME}"

    else

        mark_service_stopping "${SVCNAME}"

        return 1

    fi

}

halt() {

    service_stopped "${SVCNAME}" && ewarn "WARNING: ${SVCNAME} is already marked as stopped, but I still try to kill ${name}"

    _halt

    # TODO: удалить /sys/fs/cgroup/...

	checkconfig || return 1

    eval local STOP_PWR_TIMEOUT=\${rc_${SVCNAME//./_}__stop_power_timeout-${rc_lxc__stop_power_timeout-15}}

    eval local STOP_NOKILL_TIMEOUT=\${rc_${SVCNAME//./_}__stop_nokill_timeout-${rc_lxc__stop_nokill_timeout-15}}

    if ! service_wasinactive "${SVCNAME}"; then

        if [ -n "${STOP_PWR_TIMEOUT}" ]; then

            ebegin "Sending signal to stop ${name}"

            kill -s SIGPWR "$(eval lxc-info ${_name} --pid --no-humanize)" &>/dev/null

            eval lxc-wait ${_name} -s STOPPED -t ${STOP_PWR_TIMEOUT}

            eend $? && return 0

        fi

        if [ -n "${STOP_NOKILL_TIMEOUT}" ]; then

            ebegin "Try to request a clean shutdown ${name}"

            ( eval lxc-stop ${_name} --nokill & ) &>/dev/null

            eval lxc-wait ${_name} -s STOPPED -t ${STOP_NOKILL_TIMEOUT}

            eend $? && return 0

        fi

    fi

    _halt

}

freeze() {

    ebegin "Freeze all the processes of the container ${CONTAINER}"

    eval lxc-freeze ${_name}

    eend $? "Problem whith freezing container ${CONTAINER}" && mark_service_inactive "${SVCNAME}"

}

unfreeze() {

    if service_inactive "${SVCNAME}"; then

        ebegin "Unfreeze container ${CONTAINER}"

        eval lxc-unfreeze ${_name}

        eend $? "Problem whith unfreezing container ${CONTAINER}" && mark_service_started "${SVCNAME}"

    else

        eerror "${SVCNAME}: cannot \`unfreeze' as it has not been started"

    fi

}

	if ! [ -d /sys/fs/cgroup/cpuset/lxc/${CONTAINER} ]; then

attach() {

	    ewarn "${CONTAINER} doesn't seem to be started."

    eval lxc-attach ${_name}

	    return 0

	fi

	init_pid=$(lxc-info -n ${CONTAINER} --pid | awk '{ print $2 }')

	if [ -z "${init_pid}" ]; then

	    ewarn "${CONTAINER} doesn't seem to be running."

	    return 0

	fi

	ebegin "Shutting down system in ${CONTAINER}"

	kill -PWR ${init_pid}

	eend $?

	TIMEOUT=${TIMEOUT:-30}

	i=0

	while [ -n "$(pgrep -P ${init_pid})" -a $i -lt ${TIMEOUT} ]; do

		sleep 1

		i=$(expr $i + 1)

	done

	if [ -n "${missingprocs}" ]; then

		ewarn "Something failed to properly shut down in ${CONTAINER}"

	fi

	ebegin "Stopping ${CONTAINER}"

	lxc-stop -n ${CONTAINER}

	eend $?