|
|
#!/bin/bash
|
|
|
# Copyright 2022 Mir Calculate. http://www.calculate-linux.org
|
|
|
#
|
|
|
# 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.
|
|
|
|
|
|
TEXTDOMAIN=cl_lxc
|
|
|
export PATH="/lib/rc/bin:$PATH"
|
|
|
set -ueo pipefail
|
|
|
|
|
|
check_simultaneous_run(){ # Проверим на повторный запуск
|
|
|
lock=/tmp/cl-lxc.lock
|
|
|
if ! mkdir $lock &>/dev/null; then
|
|
|
echo $"Script launched!" >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
trap "rm -rf $lock" EXIT
|
|
|
true
|
|
|
}
|
|
|
|
|
|
print_help(){
|
|
|
usage=$(printf $"SYNOPSIS: %s [PARAMETERS?] [name]" ${0##*/})
|
|
|
if [[ "$1" == "all" ]]; then
|
|
|
echo $"$usage
|
|
|
|
|
|
${0##*/} installation, configuration and update of an LXC container with Calculate Linux on board
|
|
|
|
|
|
Parameters:
|
|
|
-P, --profile select profile flavour ('list' to view all that applies)
|
|
|
-c, --create create new container
|
|
|
--path path to container
|
|
|
-p, --prepare get rootfs ready for update
|
|
|
-u, --upgrade update container rootfs
|
|
|
--diff diff two rootfs packages
|
|
|
-R, --clear_cache clear cache
|
|
|
-m, --mirror mirror address
|
|
|
-h, --help show this help page
|
|
|
"
|
|
|
else
|
|
|
echo $usage
|
|
|
fi
|
|
|
true
|
|
|
}
|
|
|
|
|
|
get_args(){
|
|
|
check_val(){
|
|
|
if [[ "$#" == "1" || "$2" =~ ^- ]]; then
|
|
|
echo $"Parameter '$1' contains no value!" >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
}
|
|
|
profile_=
|
|
|
create_=0
|
|
|
path_=
|
|
|
prepare_=0
|
|
|
upgrade_=0
|
|
|
diff_=0
|
|
|
clear_=0
|
|
|
mirror_=mirror.calculate-linux.org
|
|
|
while (( $# > 0 )); do
|
|
|
case "$1" in
|
|
|
-P|--profile)
|
|
|
check_val $@
|
|
|
profile_=$2
|
|
|
shift
|
|
|
;;
|
|
|
-c|--create)
|
|
|
create_=1
|
|
|
;;
|
|
|
--path)
|
|
|
check_val $@
|
|
|
path_=$2
|
|
|
shift
|
|
|
;;
|
|
|
-p|--prepare)
|
|
|
prepare_=1
|
|
|
;;
|
|
|
-u|--upgrade)
|
|
|
upgrade_=1
|
|
|
;;
|
|
|
--diff)
|
|
|
diff_=1
|
|
|
;;
|
|
|
-R|--clear_cache)
|
|
|
clear_=1
|
|
|
;;
|
|
|
-m|--mirror)
|
|
|
check_val $@
|
|
|
mirror_=$2
|
|
|
shift
|
|
|
;;
|
|
|
-h|--help)
|
|
|
print_help "all"
|
|
|
exit
|
|
|
;;
|
|
|
--)
|
|
|
shift
|
|
|
break
|
|
|
;;
|
|
|
*)
|
|
|
if ! [[ $1 =~ ^- ]]; then
|
|
|
break
|
|
|
fi
|
|
|
printf $"Invalid option '%s'.\n" $1 >&2
|
|
|
exit 1
|
|
|
;;
|
|
|
esac
|
|
|
shift
|
|
|
done
|
|
|
if [ "$profile_" == 'list' ]; then
|
|
|
print_profile
|
|
|
exit 0
|
|
|
elif (( $# == 1 )); then
|
|
|
lxc_=$1
|
|
|
if [[ $lxc_ =~ [^A-Za-z0-9_\._\-] ]]; then
|
|
|
echo $"Container name contains wrong characters." >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
if [[ $lxc_ = 'scratch' ]]; then
|
|
|
echo $"The name '$lxc_' is reserved. Use a different container name." >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
else
|
|
|
print_help "usage"
|
|
|
exit 1
|
|
|
fi
|
|
|
|
|
|
true
|
|
|
}
|
|
|
|
|
|
print_profile(){
|
|
|
local profile_dir
|
|
|
if [[ -e /var/db/repos/container/profiles/profiles.desc ]]; then
|
|
|
profile_dir=/var/db/repos/container
|
|
|
elif [[ -e /var/calculate/repos/container/profiles/profiles.desc ]]; then
|
|
|
profile_dir=/var/calculate/repos/container
|
|
|
else
|
|
|
profile_dir=/var/calculate/tmp/update/container
|
|
|
if [[ ! -d $profile_dir ]]; then
|
|
|
git clone https://github.com/calculatelinux/container $profile_dir &>/dev/null
|
|
|
else
|
|
|
git -C $profile_dir pull &>/dev/null
|
|
|
fi
|
|
|
fi
|
|
|
|
|
|
# Отобразим список доступных профилей или проверим наличие запрошенного
|
|
|
if (( $# == 0 )); then
|
|
|
echo $"Profile:"
|
|
|
grep "^amd64" ${profile_dir}/profiles/profiles.desc | awk '{print " * " $2, $3}' OFS=' (' ORS=')\n'
|
|
|
return
|
|
|
else
|
|
|
if ! grep -q "^amd64\s*${1}/" ${profile_dir}/profiles/profiles.desc; then
|
|
|
return 1
|
|
|
fi
|
|
|
fi
|
|
|
}
|
|
|
|
|
|
set_vars(){
|
|
|
cl_lxc_ver=$(ls -d /var/db/pkg/sys-apps/calculate-toolkit-* 2>/dev/null) \
|
|
|
&& cl_lxc_ver=${cl_lxc_ver:39} \
|
|
|
|| cl_lxc_ver=
|
|
|
net_domain=$(hostname -f)
|
|
|
path_def=$(lxc-config lxc.lxcpath 2>/dev/null) || (
|
|
|
printf $"To run the script, install the '%s' package.\n" app-containers/lxc >&2
|
|
|
exit 1
|
|
|
)
|
|
|
|
|
|
if ! [[ $prepare_ == 1 || $upgrade_ == 1 ]]; then
|
|
|
name_lxc=$lxc_
|
|
|
name_upgrading=
|
|
|
name_rootfs=
|
|
|
status_lxc=
|
|
|
else
|
|
|
name_lxc="${lxc_}_new"
|
|
|
name_upgrading=$lxc_
|
|
|
name_rootfs="rootfs-${lxc_}"
|
|
|
if [[ $(lxc-info -s $lxc_ 2>&1 | grep RUNNING) ]]; then
|
|
|
status_lxc='RUNNING'
|
|
|
else
|
|
|
status_lxc='STOPPED'
|
|
|
fi
|
|
|
fi
|
|
|
|
|
|
if [ -L $path_def/$lxc_ ]; then
|
|
|
path_work=$(sed 's/\/[^/]*$//' <<< $(realpath $path_def/$lxc_))
|
|
|
if [ -n "$path_" ] && [ $path_ != "$path_work" ]; then
|
|
|
printf $"Wrong --path parameter, container created in '%s'.\n" $path_work >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
elif [ -n "$path_" ] && [ "$path_" != "$path_def" ]; then
|
|
|
path_work=$path_
|
|
|
else
|
|
|
path_work=$path_def
|
|
|
fi
|
|
|
|
|
|
path_lxc=$path_work/$name_lxc
|
|
|
path_cache=$path_work/.cache
|
|
|
path_lxc_prepare=$path_cache/rootfs-$lxc_
|
|
|
|
|
|
|
|
|
if [ $path_def = "$path_work" ]; then
|
|
|
path_change=
|
|
|
if [ ! -d $path_work ]; then
|
|
|
mkdir -p $path_work
|
|
|
fi
|
|
|
else
|
|
|
path_change=$path_work
|
|
|
if [ ! -d $path_work ]; then
|
|
|
printf $"Directory '%s' is not found.\n" $path_work >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
fi
|
|
|
|
|
|
type_fs=$(df -Th $path_work | awk 'NR==2 {print $2}')
|
|
|
|
|
|
if [[ $prepare_ == 1 || $upgrade_ == 1 ]] && [ -f $path_work/$lxc_/config ]; then
|
|
|
# Считаем номер текущего корня обновляемой системы и определим новый
|
|
|
num_cur=$(grep lxc.rootfs.path $path_work/$lxc_/config | sed 's/.*rootfs//')
|
|
|
num_next=$(ls -d $path_work/$lxc_/rootfs* | sed 's/.*rootfs//' | sort -n | tail -n 1)
|
|
|
let "num_next+=1"
|
|
|
else
|
|
|
num_cur=
|
|
|
num_next=
|
|
|
fi
|
|
|
|
|
|
# taiga/amd64/20 -> taiga
|
|
|
lxc_profile=${profile_%%/*}
|
|
|
|
|
|
if [[ $lxc_profile == "" ]]; then
|
|
|
if [[ $prepare_ == 1 || $upgrade_ == 1 ]]; then
|
|
|
lxc_profile=$(file $path_work/$lxc_/rootfs$num_cur/etc/portage/make.profile | \
|
|
|
awk -F '/profiles/' '{ print $2 }' | awk -F '/' '{ print $1 }')
|
|
|
# совместимость со старыми системами
|
|
|
case "$lxc_profile" in
|
|
|
CCS|CDS)
|
|
|
lxc_profile=scratch
|
|
|
;;
|
|
|
CCG)
|
|
|
lxc_profile=games
|
|
|
;;
|
|
|
esac
|
|
|
else
|
|
|
lxc_profile=scratch
|
|
|
fi
|
|
|
else
|
|
|
print_profile $lxc_profile || {
|
|
|
echo $"Wrong --profile parameter, use 'list' to view accepted values." >&2
|
|
|
exit 1
|
|
|
}
|
|
|
fi
|
|
|
true
|
|
|
}
|
|
|
|
|
|
debug_vars(){
|
|
|
local log=/var/log/calculate/cl-lxc.log
|
|
|
cat > /var/log/calculate/cl-lxc.log <<-EOF
|
|
|
cl_lxc_ver = $cl_lxc_ver
|
|
|
net_domain = $net_domain
|
|
|
path_def = $path_def
|
|
|
name_lxc = $name_lxc
|
|
|
name_upgrading = $name_upgrading
|
|
|
name_rootfs = $name_rootfs
|
|
|
status_lxc = $status_lxc
|
|
|
path_work = $path_work
|
|
|
path_lxc = $path_lxc
|
|
|
path_cache = $path_cache
|
|
|
path_lxc_prepare = $path_lxc_prepare
|
|
|
path_change = $path_change
|
|
|
type_fs = $type_fs
|
|
|
num_cur = $num_cur
|
|
|
num_next = $num_next
|
|
|
lxc_profile = $lxc_profile
|
|
|
EOF
|
|
|
}
|
|
|
|
|
|
show(){
|
|
|
echo ---------------------------------------------
|
|
|
echo $@
|
|
|
echo ---------------------------------------------
|
|
|
}
|
|
|
|
|
|
launch_message(){
|
|
|
printf $"Your container is ready. To start it, please run 'lxc-start %s'.\n" $name_lxc
|
|
|
}
|
|
|
|
|
|
check_vars(){
|
|
|
program_name=${0##*/}
|
|
|
if [ "$path_" != '' ] && ! [ -d "$path_" ]; then
|
|
|
printf $"Failed to find directory '%s'.\n" $path_ >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
if [ $create_ == 1 ] && [[ -e $path_lxc || -e $path_def/$name_lxc ]]; then
|
|
|
printf $"Wrong parameter %s, container '%s' exists already!\n" --create $name_lxc >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
if [ $create_ == 0 ] && [ -n "$path_" ]; then
|
|
|
printf $"Parameter %s should be used to create a container.\n" --path >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
|
|
|
if [[ $prepare_ == 1 || $upgrade_ == 1 ]] && [ ! -e $path_work/$name_upgrading ]; then
|
|
|
local param_name='--upgrade'
|
|
|
if [ $prepare_ == 1 ]; then
|
|
|
param_name='--prepare'
|
|
|
fi
|
|
|
printf $"Wrong parameter %s, container '%s' does not exist!\n" $param_name $name_upgrading >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
if [[ $upgrade_ == 1 && $prepare_ == 0 && ! -d $path_lxc_prepare ]] ||
|
|
|
[[ $upgrade_ == 1 && $prepare_ == 0 && $clear_ == 1 ]]
|
|
|
then
|
|
|
printf $"Before update, prepare an image using option %s. This operation may be combined with others.\n" \
|
|
|
--prepare >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
if [ $create_ == 0 ] && [ $prepare_ == 0 ] && [ $upgrade_ == 0 ]; then
|
|
|
if [ ! -e $path_lxc ]; then
|
|
|
printf $"No operation specified. Call %s to create a container.\n" \
|
|
|
"'$program_name -c $name_lxc'" >&2
|
|
|
exit 1
|
|
|
elif [ ! -d $path_lxc_prepare ]; then
|
|
|
printf $"No operation specified. Call %s to prepare an update image for the container.\n" \
|
|
|
"'$program_name -p $name_lxc'" >&2
|
|
|
exit 1
|
|
|
elif [ -d $path_lxc_prepare ]; then
|
|
|
printf $"No operation specified. Call %s to update the container.\n" \
|
|
|
"'$program_name -u $name_lxc'" >&2
|
|
|
exit 1
|
|
|
else
|
|
|
print_help "usage" >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
fi
|
|
|
if [ $path_def != '/var/calculate/lxc' ]; then
|
|
|
printf $"lxc.lxcpath must contain the path to '/var/calculate/lxc'.\n" >&2
|
|
|
exit 1
|
|
|
fi
|
|
|
true
|
|
|
}
|
|
|
|
|
|
create_base(){
|
|
|
ebegin $"Downloading Calculate Linux"
|
|
|
|
|
|
# Создадим подтом, чтобы контейнер не участвовал в бэкапе btrbk
|
|
|
if [ ! -e $path_cache ]; then
|
|
|
if [ $type_fs = 'btrfs' ]; then
|
|
|
btrfs subvolume create $path_cache &>/dev/null
|
|
|
else
|
|
|
mkdir $path_cache
|
|
|
fi
|
|
|
fi
|
|
|
trap "rm -rf $path_def/scratch" SIGINT
|
|
|
lxc-create -n scratch -t download -- --server $mirror_ \
|
|
|
--arch x86_64 --dist scratch --release live \
|
|
|
2>>/var/log/calculate/cl-lxc-error.log >/dev/null || {
|
|
|
eend $? || true
|
|
|
eerror $"Failed to run lxc-create" >&2
|
|
|
exit $?
|
|
|
}
|
|
|
eend
|
|
|
trap - SIGINT
|
|
|
mv $path_def/scratch $path_cache/scratch
|
|
|
true
|
|
|
}
|
|
|
|
|
|
create_lxc(){
|
|
|
echo $"Creating container $name_lxc"
|
|
|
if [ $type_fs = 'btrfs' ]; then
|
|
|
btrfs subvolume create $path_lxc >/dev/null || {
|
|
|
eend $? || true
|
|
|
eerror $"Failed to create subvolume $path_lxc" >&2
|
|
|
exit $?
|
|
|
}
|
|
|
else
|
|
|
mkdir $path_lxc
|
|
|
fi
|
|
|
chmod 700 $path_lxc
|
|
|
|
|
|
local reflink='' && [ $type_fs = 'btrfs' ] && reflink='--reflink'
|
|
|
if [ -d "$path_lxc_prepare" ]; then
|
|
|
ebegin $"Restoring rootfs image from cache"
|
|
|
cp -a $reflink $path_lxc_prepare $path_lxc/rootfs
|
|
|
eend
|
|
|
else
|
|
|
ebegin $"Copying base rootfs"
|
|
|
cp -a $reflink $path_cache/scratch/rootfs $path_lxc/rootfs
|
|
|
eend
|
|
|
fi
|
|
|
|
|
|
if [ -n "$path_change" ]; then
|
|
|
ln -s $path_lxc $path_def/$name_lxc
|
|
|
fi
|
|
|
|
|
|
ebegin $"Preparing base mount paths"
|
|
|
for path_res in usr/portage \
|
|
|
var/cache/edb/binhost \
|
|
|
var/calculate/distfiles \
|
|
|
var/calculate/packages \
|
|
|
var/db/repos/calculate \
|
|
|
var/db/repos/gentoo
|
|
|
do
|
|
|
path_res=${path_lxc}/rootfs/${path_res}
|
|
|
if [ -e $path_res ]; then
|
|
|
rm -rf $path_res
|
|
|
mkdir $path_res
|
|
|
fi
|
|
|
done
|
|
|
eend
|
|
|
|
|
|
local calculate_mount= calculate_dir=
|
|
|
if [ $prepare_ == 0 ]; then
|
|
|
ebegin $"Moving /var/calculate to a separate mount point"
|
|
|
# Очистка и создание пути для монтирования ресурсов из хостовой машины
|
|
|
mv $path_lxc/rootfs/var/calculate $path_lxc
|
|
|
mkdir $path_lxc/rootfs/var/calculate
|
|
|
calculate_mount="lxc.mount.entry = ${path_lxc}/calculate var/calculate none rw,bind 0 0"
|
|
|
calculate_dir="${path_lxc}/calculate"
|
|
|
eend
|
|
|
else
|
|
|
calculate_dir="${path_lxc}/rootfs/var/calculate"
|
|
|
fi
|
|
|
|
|
|
local portage_mount= gentoo_from= gentoo_to=
|
|
|
if [ -d /var/db/repos/gentoo ]; then
|
|
|
gentoo_from='/var/db/repos/gentoo'
|
|
|
else
|
|
|
gentoo_from='/usr/portage'
|
|
|
fi
|
|
|
if [ -d $path_lxc/rootfs/var/db/repos/gentoo ]; then
|
|
|
gentoo_to='var/db/repos/gentoo'
|
|
|
else
|
|
|
gentoo_to='usr/portage'
|
|
|
fi
|
|
|
portage_mount="lxc.mount.entry = ${gentoo_from} ${gentoo_to} none ro,bind 0 0"
|
|
|
|
|
|
if [[ ! -e /var/db/repos/container ]]; then
|
|
|
container_mount="lxc.mount.entry = /var/calculate/repos/container var/db/repos/container none ro,bind 0 0"
|
|
|
if [[ -e /var/calculate/repos/container ]]; then
|
|
|
rm -rf ${path_lxc}/rootfs/var/db/repos/container
|
|
|
else
|
|
|
mv $path_lxc/rootfs/var/db/repos/container /var/calculate/repos
|
|
|
|
|
|
if grep -q github.com $path_lxc/rootfs/etc/portage/repos.conf/zz-calculate.conf; then
|
|
|
local repo_container='https://github.com/calculatelinux/container'
|
|
|
else
|
|
|
local repo_container='https://git.calculate-linux.org/calculate/container-overlay'
|
|
|
fi
|
|
|
cat <<- EOF > /etc/portage/repos.conf/cl-lxc.conf
|
|
|
[container]
|
|
|
priority = 50
|
|
|
sync-uri = $repo_container
|
|
|
location = /var/calculate/repos/container
|
|
|
auto-sync = Yes
|
|
|
sync-type = git
|
|
|
EOF
|
|
|
fi
|
|
|
else
|
|
|
# для совместимости с предыдушими установками
|
|
|
container_mount="lxc.mount.entry = /var/db/repos/container var/db/repos/container none ro,bind 0 0"
|
|
|
rm -rf ${path_lxc}/rootfs/var/db/repos/container
|
|
|
fi
|
|
|
mkdir $path_lxc/rootfs/var/db/repos/container
|
|
|
|
|
|
|
|
|
ebegin $"Running container setup"
|
|
|
local net_conf=
|
|
|
if [ $prepare_ == 1 ] || [ ! -L /sys/class/net/br0 ]; then
|
|
|
net_conf=none
|
|
|
network_conf="lxc.net.0.type = none"
|
|
|
cp /etc/resolv.conf $path_lxc/rootfs/etc
|
|
|
echo -e "\nrc_provide=\"net\"" >> $path_lxc/rootfs/etc/conf.d/net
|
|
|
else
|
|
|
net_conf=veth
|
|
|
local random_mac=$(printf '06:%02X:%02X:%02X:%02X:%02X\n' \
|
|
|
$((RANDOM%256)) $((RANDOM%256)) $((RANDOM%256)) $((RANDOM%256)) $((RANDOM%256)))
|
|
|
local veth_pair="lxc.net.0.veth.pair = lxc-${name_lxc::11}"
|
|
|
if grep -q "$veth_pair" -r ${path_def}/*/config &>/dev/null; then
|
|
|
# исключим настройку сетевого имени, если такое уже используется
|
|
|
veth_pair="#${veth_pair}"
|
|
|
fi
|
|
|
network_conf=$(cat <<- EOF
|
|
|
lxc.net.0.type = veth
|
|
|
lxc.net.0.flags = up
|
|
|
lxc.net.0.name = eth0
|
|
|
lxc.net.0.link = br0
|
|
|
lxc.net.0.hwaddr = ${random_mac}
|
|
|
${veth_pair}
|
|
|
EOF
|
|
|
)
|
|
|
fi
|
|
|
cat <<- EOF >> ${path_lxc}/config
|
|
|
#------------------------------------------------------------------------------
|
|
|
# Modified cl-lxc-${cl_lxc_ver}
|
|
|
# For additional config options, please look at lxc.container.conf(5)
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
|
|
# Distribution configuration
|
|
|
lxc.include = /usr/share/lxc/config/common.conf
|
|
|
lxc.arch = x86_64
|
|
|
lxc.mount.entry = none dev/shm tmpfs rw,nosuid,nodev,create=dir
|
|
|
|
|
|
# Container specific configuration
|
|
|
lxc.rootfs.path = dir:/var/calculate/lxc/${name_lxc}/rootfs
|
|
|
lxc.uts.name = ${name_lxc}
|
|
|
|
|
|
# Network configuration
|
|
|
${network_conf}
|
|
|
|
|
|
# Mount points
|
|
|
${calculate_mount}
|
|
|
${container_mount}
|
|
|
lxc.mount.entry = /var/db/repos/calculate var/db/repos/calculate none ro,bind 0 0
|
|
|
${portage_mount}
|
|
|
lxc.mount.entry = /var/cache/edb/binhost var/cache/edb/binhost none ro,bind 0 0
|
|
|
lxc.mount.entry = /var/calculate/packages var/calculate/packages none rw,bind 0 0
|
|
|
lxc.mount.entry = /var/calculate/distfiles var/calculate/distfiles none rw,bind 0 0
|
|
|
EOF
|
|
|
eend
|
|
|
|
|
|
ebegin $"Configuring utility variables"
|
|
|
cat <<- EOF > ${calculate_dir}/calculate.env
|
|
|
[update]
|
|
|
cl_update_rep_name =
|
|
|
cl_update_rep_url =
|
|
|
cl_update_eixupdate_force = force
|
|
|
cl_update_force_fix_set = on
|
|
|
EOF
|
|
|
eend
|
|
|
|
|
|
ebegin $"Preparing first boot setup script"
|
|
|
cat <<- EOF > $path_lxc/rootfs/etc/local.d/firststart.start
|
|
|
rm /etc/local.d/firststart.start
|
|
|
rm /etc/calculate/calculate.env
|
|
|
EOF
|
|
|
chmod 755 $path_lxc/rootfs/etc/local.d/firststart.start
|
|
|
|
|
|
cat <<- EOF > $path_lxc/rootfs/etc/calculate/calculate.env
|
|
|
# Parameters for firststart.start
|
|
|
[install]
|
|
|
os_install_net_hostname = ${name_lxc}
|
|
|
os_install_net_domain = ${net_domain}
|
|
|
os_install_locale_lang = ${LANG/.UTF-8/}
|
|
|
os_install_clock_timezone = $(cat /etc/timezone)
|
|
|
EOF
|
|
|
eend
|
|
|
|
|
|
ebegin $"Creating templates"
|
|
|
mkdir -p ${calculate_dir}/templates/default
|
|
|
cat <<- EOF > ${calculate_dir}/templates/default/.calculate_directory
|
|
|
# Calculate env=install ac_install_live==on append=skip
|
|
|
EOF
|
|
|
if [ $net_conf == veth ]; then
|
|
|
cat <<- EOF > ${calculate_dir}/templates/default/runlevel.eth0
|
|
|
# Calculate mergepkg(sys-apps/openrc)!= path=/etc/runlevels/default name=net.eth0 protected link=/etc/init.d/net.lo symbolic
|
|
|
EOF
|
|
|
fi
|
|
|
cat <<- EOF > ${calculate_dir}/templates/default/portage.binhost
|
|
|
# Calculate mergepkg(sys-apps/portage)!= path=/etc/portage/make.conf name=binhost protected comment=#
|
|
|
$(emerge --info 2>/dev/null | grep PORTAGE_BINHOST)
|
|
|
EOF
|
|
|
eend
|
|
|
|
|
|
if [[ -z "$name_upgrading" && $lxc_profile == 'scratch' ]]; then
|
|
|
launch_message
|
|
|
fi
|
|
|
}
|
|
|
|
|
|
start_container(){
|
|
|
ebegin $"Starting container"
|
|
|
lxc-start $name_lxc
|
|
|
# ожидание первоначальной настройки контейнера
|
|
|
while ! lxc-attach $name_lxc -- ps ax | grep 'init \[3\]' > /dev/null; do
|
|
|
sleep 0.1
|
|
|
done
|
|
|
eend
|
|
|
}
|
|
|
|
|
|
change_profile(){
|
|
|
echo
|
|
|
echo $"Change the profile to $lxc_profile"
|
|
|
start_container
|
|
|
|
|
|
cl-update -s
|
|
|
|
|
|
lxc-attach $name_lxc -- cl-update-profile -f $lxc_profile
|
|
|
|
|
|
echo
|
|
|
echo $"Install packages from profile $lxc_profile"
|
|
|
einfo $"Launching package update"
|
|
|
lxc-attach $name_lxc -- cl-update -f
|
|
|
eend
|
|
|
|
|
|
launch_message
|
|
|
}
|
|
|
|
|
|
update_prepare(){
|
|
|
#printf $"Package update for container %s\n" $name_lxc
|
|
|
ebegin $"Moving installed packages, flags and masks from main container"
|
|
|
for migrate_file in /etc/portage/package.accept_keywords/custom \
|
|
|
/etc/portage/package.mask/custom \
|
|
|
/etc/portage/package.unmask/custom \
|
|
|
/etc/portage/package.use/custom \
|
|
|
/etc/portage/sets/custom
|
|
|
do
|
|
|
cp ${path_work}/${name_upgrading}/rootfs${num_cur}${migrate_file} \
|
|
|
${path_lxc}/rootfs${migrate_file} &>/dev/null || true
|
|
|
done
|
|
|
eend
|
|
|
|
|
|
ebegin $"Creating mount points"
|
|
|
for mount_point in $(grep '^lxc.mount.entry' $path_work/$name_upgrading/config | awk {'print $4'}); do
|
|
|
if [ ! -e "$path_lxc/rootfs/$mount_point" ]; then
|
|
|
mkdir -p "$path_lxc/rootfs/$mount_point"
|
|
|
fi
|
|
|
done
|
|
|
eend
|
|
|
|
|
|
ebegin $"Preparing first boot setup script"
|
|
|
cat <<- EOF > $path_lxc/rootfs/etc/local.d/firststart.start
|
|
|
rm /etc/local.d/firststart.start
|
|
|
rm /etc/calculate/calculate.env
|
|
|
EOF
|
|
|
chmod 755 $path_lxc/rootfs/etc/local.d/firststart.start
|
|
|
|
|
|
# если обновляемый контейнер ни разу не запускался, возьем временный конфиг
|
|
|
if [[ -e ${path_work}/${name_upgrading}/rootfs${num_cur}/etc/calculate/calculate.env ]]; then
|
|
|
cp ${path_work}/${name_upgrading}/rootfs${num_cur}/etc/calculate/calculate.env \
|
|
|
$path_lxc/rootfs/etc/calculate
|
|
|
else
|
|
|
local lxc_host=$(grep localhost ${path_work}/${name_upgrading}/rootfs${num_cur}/etc/hosts | awk '{print $2}')
|
|
|
local os_install_net_hostname=${lxc_host%%.*}
|
|
|
local os_install_net_domain=${lxc_host#*.}
|
|
|
local os_install_locale_lang=$(grep 'LANG=' ${path_work}/${name_upgrading}/rootfs${num_cur}/etc/env.d/02locale)
|
|
|
local os_install_clock_timezone=$(cat ${path_work}/${name_upgrading}/rootfs${num_cur}/etc/timezone)
|
|
|
|
|
|
cat <<- EOF > $path_lxc/rootfs/etc/calculate/calculate.env
|
|
|
# Parameters for firststart.start
|
|
|
[install]
|
|
|
os_install_net_hostname = ${os_install_net_hostname}
|
|
|
os_install_net_domain = ${os_install_net_domain}
|
|
|
os_install_locale_lang = ${os_install_locale_lang:6:5}
|
|
|
os_install_clock_timezone = ${os_install_clock_timezone}
|
|
|
EOF
|
|
|
fi
|
|
|
eend
|
|
|
|
|
|
start_container
|
|
|
|
|
|
cl-update -s
|
|
|
|
|
|
if [[ $(file $path_lxc/rootfs/etc/portage/make.profile | \
|
|
|
awk -F '/profiles/' '{ print $2 }' | awk -F '/' '{ print $1 }') != $lxc_profile ]]
|
|
|
then
|
|
|
echo
|
|
|
echo $"Change profile to $lxc_profile"
|
|
|
lxc-attach $name_lxc -- cl-update-profile -f $lxc_profile
|
|
|
fi
|
|
|
|
|
|
echo
|
|
|
echo $"Launching package update"
|
|
|
lxc-attach $name_lxc -- cl-update -f
|
|
|
rm -rf "$path_lxc/rootfs/var/calculate/{tmp/*,templates/*}"
|
|
|
find $path_lxc/rootfs/etc/init.d -type l -name net.* -exec unlink {} \;
|
|
|
cd $path_lxc/rootfs/etc/runlevels/boot
|
|
|
ln -s /etc/init.d/calculate .
|
|
|
cd - &>/dev/null
|
|
|
|
|
|
ebegin $"Stopping container"
|
|
|
lxc-stop $name_lxc
|
|
|
eend
|
|
|
|
|
|
ebegin $"Saving image for update"
|
|
|
if [ -d $path_lxc_prepare ]; then
|
|
|
rm -r $path_lxc_prepare
|
|
|
fi
|
|
|
mv $path_lxc/rootfs $path_lxc_prepare
|
|
|
eend
|
|
|
|
|
|
ebegin $"Removing temporary container directory $name_lxc"
|
|
|
if [ $type_fs = 'btrfs' ]; then
|
|
|
btrfs subvolume delete $path_lxc &>/dev/null
|
|
|
if [ -n "$path_change" ]; then
|
|
|
rm $path_def/$name_lxc # удалим символическую ссылку
|
|
|
fi
|
|
|
else
|
|
|
rm -rf $path_lxc
|
|
|
fi
|
|
|
eend
|
|
|
|
|
|
[ $diff_ == 1 ] && diff_pkg
|
|
|
|
|
|
einfo $"Image for update ready. Now you can run '$program_name -u $name_upgrading' to update."
|
|
|
return
|
|
|
|
|
|
}
|
|
|
|
|
|
upgrade_lxc(){
|
|
|
echo $"Preparing to start new root"
|
|
|
|
|
|
ebegin $"Moving image to $name_upgrading/rootfs$num_next"
|
|
|
local reflink=
|
|
|
if [ $type_fs = 'btrfs' ]; then
|
|
|
reflink='--reflink'
|
|
|
fi
|
|
|
cp -a $reflink $path_lxc_prepare $path_work/$name_upgrading/rootfs$num_next
|
|
|
rm -rf $path_work/$name_upgrading/rootfs$num_next/var/calculate/*
|
|
|
eend
|
|
|
|
|
|
ebegin $"Copying network settings from main container"
|
|
|
cp $path_work/$name_upgrading/rootfs$num_cur/etc/conf.d/net \
|
|
|
$path_work/$name_upgrading/rootfs$num_next/etc/conf.d/net
|
|
|
eend
|
|
|
|
|
|
ebegin $"Copying hash of root password"
|
|
|
root=$(grep '^root:' $path_work/$name_upgrading/rootfs$num_cur/etc/shadow | sed 's/:/\\:/g')
|
|
|
sed -i "s:^root\:.*$:$root:" $path_work/$name_upgrading/rootfs$num_next/etc/shadow
|
|
|
eend
|
|
|
|
|
|
ebegin $"Copying ssh keys"
|
|
|
cp $path_work/$name_upgrading/rootfs$num_cur/etc/ssh/ssh_*key* \
|
|
|
$path_work/$name_upgrading/rootfs$num_next/etc/ssh 2>/dev/null || true
|
|
|
eend
|
|
|
|
|
|
ebegin $"Preparing first boot setup script"
|
|
|
cat <<- EOF > $path_work/$name_upgrading/rootfs$num_next/etc/local.d/firststart.start
|
|
|
cl-core --method setup_system --no-progress --usenew-conf --network on
|
|
|
openrc
|
|
|
rm /etc/local.d/firststart.start
|
|
|
EOF
|
|
|
chmod 755 $path_work/$name_upgrading/rootfs$num_next/etc/local.d/firststart.start
|
|
|
eend
|
|
|
|
|
|
ebegin $"New root setup"
|
|
|
sed -i "s#$path_def/$name_upgrading/rootfs[0-9]*#$path_def/$name_upgrading/rootfs$num_next#" \
|
|
|
$path_work/$name_upgrading/config
|
|
|
eend
|
|
|
|
|
|
if [ ! -z $(lxc-ls --running --filter "^$name_upgrading$") ]; then
|
|
|
einfo $"Stopping container $name_upgrading"
|
|
|
lxc-stop $name_upgrading
|
|
|
eend
|
|
|
fi
|
|
|
|
|
|
if [ "$status_lxc" = 'RUNNING' ]; then
|
|
|
einfo $"Launching container $name_upgrading"
|
|
|
lxc-start $name_upgrading
|
|
|
eend
|
|
|
fi
|
|
|
|
|
|
[ $diff_ == 1 ] && diff_pkg # Отобразим разницу в пакетах
|
|
|
|
|
|
while ! (test -a $path_work/$name_upgrading/rootfs$num_next/etc/resolv.conf); do
|
|
|
sleep 0.1
|
|
|
done
|
|
|
einfo $(lxc-info -i $name_upgrading)
|
|
|
|
|
|
printf $"Container updated."
|
|
|
if [ "$status_lxc" = 'STOPPED' ]; then
|
|
|
printf ' '
|
|
|
printf $"To start it, please run 'lxc-start %s'.\n" $name_upgrading
|
|
|
else
|
|
|
echo
|
|
|
fi
|
|
|
true
|
|
|
}
|
|
|
|
|
|
diff_pkg(){
|
|
|
# Считаем версии сборок
|
|
|
cur_ver=$(grep os_linux_build $path_work/$name_upgrading/rootfs$num_cur/var/lib/calculate/calculate.env | sed 's/.*os_linux_build\s*=\s*//')
|
|
|
next_ver=$(grep os_linux_build $path_lxc_prepare/var/lib/calculate/calculate.env | sed 's/.*os_linux_build\s*=\s*//')
|
|
|
|
|
|
printf $"Diffs between %s and %s versions:\n" $cur_ver $next_ver
|
|
|
find $path_work/$name_upgrading/rootfs$num_cur/var/db/pkg/ -type d | sed 's/.*db\/pkg\///' | grep \/ | sort > $lock/cur
|
|
|
find $path_lxc_prepare/var/db/pkg/ -type d | sed 's/.*db\/pkg\///' | grep \/ | sort > $lock/new
|
|
|
cp $lock/new $lock/work
|
|
|
|
|
|
while IFS= read -r pkg; do
|
|
|
if grep -q $pkg$ $lock/cur; then
|
|
|
sed -i "/$pkg/d" $lock/new
|
|
|
sed -i "/$pkg/d" $lock/cur
|
|
|
fi
|
|
|
done <<< $(awk -F / '{print $2}' $lock/work)
|
|
|
if [ ! -s $lock/new ] && [ ! -s $lock/cur ]; then
|
|
|
einfo $"No difference detected"
|
|
|
else
|
|
|
diff $lock/new $lock/cur || true
|
|
|
echo
|
|
|
fi
|
|
|
true
|
|
|
}
|
|
|
|
|
|
clear_cache(){
|
|
|
ebegin $"Clearing cache"
|
|
|
rm -rf /var/cache/lxc/download/*
|
|
|
|
|
|
if [[ -e /var/calculate/lxc/.cache ]]; then
|
|
|
if [[ $(df -Th /var/calculate/lxc | awk 'NR==2 {print $2}') == btrfs ]]; then
|
|
|
btrfs subvolume delete /var/calculate/lxc/.cache > /dev/null
|
|
|
else
|
|
|
rm -rf /var/calculate/lxc/.cache
|
|
|
fi
|
|
|
fi
|
|
|
|
|
|
for i in /var/calculate/lxc/*; do
|
|
|
if [[ $i == /var/calulate/lxc/* ]]; then
|
|
|
break
|
|
|
fi
|
|
|
# разыменуем символические ссылки чтобы почистить кэши на других разделах
|
|
|
if [[ -L $i ]]; then
|
|
|
cache_dir=$(realpath $i)
|
|
|
cache_dir=${cache_dir%/*}
|
|
|
if [[ -e $cache_dir/.cache ]]; then
|
|
|
if [[ $(df -Th $cache_dir | awk 'NR==2 {print $2}') == btrfs ]]; then
|
|
|
btrfs subvolume delete $cache_dir/.cache > /dev/null
|
|
|
else
|
|
|
rm -rf $cache_dir/.cache
|
|
|
fi
|
|
|
fi
|
|
|
fi
|
|
|
done
|
|
|
eend
|
|
|
}
|
|
|
|
|
|
|
|
|
# Обработка параметров вызова скрипта
|
|
|
save=$IFS
|
|
|
IFS=$' =\n'
|
|
|
get_args $@
|
|
|
IFS=$save
|
|
|
|
|
|
# Проверка одновременного запуска
|
|
|
check_simultaneous_run
|
|
|
|
|
|
# Установка значений переменных
|
|
|
set_vars
|
|
|
|
|
|
# Логирование значений переменных
|
|
|
debug_vars
|
|
|
|
|
|
# Проверка параметров запуска
|
|
|
check_vars
|
|
|
|
|
|
# Чистка кэша
|
|
|
# пустой файл partial когда lxc-create был прерван
|
|
|
if [[ $clear_ == 1 ]]; then
|
|
|
clear_cache
|
|
|
fi
|
|
|
|
|
|
# Создание базового контейнера
|
|
|
if [[ $create_ == 1 || $prepare_ == 1 ]] && [ ! -d "$path_cache/scratch" ]; then
|
|
|
create_base
|
|
|
fi
|
|
|
|
|
|
# Создание контейнера
|
|
|
if [[ $create_ == 1 || $prepare_ == 1 ]]; then
|
|
|
create_lxc
|
|
|
|
|
|
# если задан профиль при создании контейнера:
|
|
|
# запустим контейнер, обновим оверлеи (container), выберем профиль и обновим пакеты
|
|
|
if [[ $prepare_ == 0 && $lxc_profile != 'scratch' ]]; then
|
|
|
change_profile
|
|
|
fi
|
|
|
fi
|
|
|
|
|
|
# Обновление пакетов контейнера
|
|
|
if [ $prepare_ == 1 ]; then
|
|
|
update_prepare
|
|
|
fi
|
|
|
|
|
|
# Обновление контейнера
|
|
|
if [ $upgrade_ == 1 ]; then
|
|
|
upgrade_lxc
|
|
|
fi
|
|
|
|
|
|
true
|
