path: root/installer/slxossetup

#! /bin/sh
#
# slxossetup - OpenSLX script for OS setup
#
# (c) 2006 - OpenSLX.com
#
# Lars Müller <lm@openslx.com>
#

: ${SLX_CONFIG_PATH:=/etc/opt/openslx}
: ${SLX_PRIVATE_PATH:=/var/opt/openslx}
: ${SLX_BOOTSTRAP_PATH:="/slxbootstrap"}
: ${SLX_STAGE1_FINAL_PATH:="/slxfinal"}

SLX_SYSTEM_NAME=$1
test "$2" && \
	SLX_OSSETUP_MODE=$2 ||
	SLX_OSSETUP_MODE="bootstrap"

PATH="/sbin:/bin:/usr/bin:/usr/sbin"

for binary in smart; do
	if ! type -p "${binary}" >/dev/null; then
		echo "$0: Error, required binary, ${binary} not found in PATH, ${PATH}! "
		exit 1
	fi
done

if test -z "${SLX_SYSTEM_NAME}"; then
	echo "$0: Error, <system-name> not provided! "
	exit 1
fi
SLX_SYSTEM_BASENAME="${SLX_SYSTEM_NAME%%-*}"
SLX_SYSTEM_VARIANTNAME="${SLX_SYSTEM_NAME##*-}"
test "${SLX_SYSTEM_VARIANTNAME}" = "${SLX_SYSTEM_BASENAME}" && \
	unset SLX_SYSTEM_VARIANTNAME
for dir in . ${SLX_CONFIG_PATH}; do
	if test -d "${dir}/systems/${SLX_SYSTEM_BASENAME}"; then
		SLX_SYSTEM_CONFIG_PATH="${dir}/systems/${SLX_SYSTEM_BASENAME}"
		break
	fi
done

for dir in ${SLX_CONFIG_PATH} .; do
	for file in settings.default settings.local; do
		file="${dir}/${file}"
		test -f "${file}" && \
			. "${file}"
	done
done

SLX_BUSYBOX_CHROOT_NAME="busybox_chroot"

# Read config files for a particular system
for suffix in "" local ${SLX_SYSTEM_VARIANTNAME}; do
	test -f "${SLX_SYSTEM_CONFIG_PATH}/settings${suffix:+.$suffix}" && \
		. "${SLX_SYSTEM_CONFIG_PATH}/settings${suffix:+.$suffix}"
done

function setup_busybox_init()
{
	for dir in ${SLX_STAGE1_PATH}; do
		if test -d "${dir}"; then
			echo "$0: Error, ${dir} already exists! "
			exit 1
		fi
	done
}

function setup_busybox_chroot()
{
	local dir file PERL_PATH BUSYBOX_PATH BUSYBOX_LINKS_PATH REQUIRED_LIBS

	BUSYBOX_PATH="${SLX_SHARE_PATH}/busybox/busybox"
	BUSYBOX_LINKS_PATH="${SLX_SHARE_PATH}/busybox/busybox.links"

	case "${REPO_TYPE}" in
		*deb*)
			PERL_PATH=$( type -p perl)
			if test -z "${PERL_PATH}"; then
				echo "$0: Error, perl is not in your path, $PATH."
				exit 1
			fi
			test -d "${CHROOT_DIR}/usr/bin/" || \
				mkdir -p "${CHROOT_DIR}/usr/bin/"
			cp -p "${PERL_PATH}" "${CHROOT_DIR}/usr/bin/"
		;;
	esac

	test -d "${CHROOT_DIR}/bin" || \
		mkdir -p "${CHROOT_DIR}/bin"
	cp -p "${BUSYBOX_PATH}" "${CHROOT_DIR}/bin/"

	REQUIRED_LIBS=$( for file in ${CHROOT_DIR}/bin/* ${CHROOT_DIR}/usr/bin/*; do
		test -e $file || \
			continue
		${SLX_BIN_PATH}/slxldd $file;
	done)

	for file in ${REQUIRED_LIBS}; do
		test -e "${CHROOT_DIR}/${file}" && \
			continue
		dir="${CHROOT_DIR}/${file%/*}"
		test -d "${dir}" || \
			mkdir -p "${dir}"
		cp -p "${file}" "${dir}/"
	done

	while read file; do
		dir="${CHROOT_DIR}/${file%/*}"
		test -d "${dir}" || \
			mkdir -p "${dir}"
		ln -s "/bin/busybox" "${CHROOT_DIR}/${file}"
	done <"${BUSYBOX_LINKS_PATH}"

	test -d "${CHROOT_DIR}/etc" || \
		mkdir -p "${CHROOT_DIR}/etc"
	cp -p /etc/resolv.conf "${CHROOT_DIR}/etc/"

	# FIXME this might not be enough to satisfy the resolver
	for file in /lib/libnss_dns* /lib/libresolv*; do
		test -e "${file}" || \
			continue
		dir="${CHROOT_DIR}/${file%/*}"
		test -d "${dir}" || \
			mkdir -p "${dir}"
		cp -p "${file}" "${dir}/"
	done
}

function setup_busybox_stage1_config()
{
	local key value CONFIG_FILE
	
	CONFIG_FILE="${CHROOT_DIR}/etc/slxbootstrap.conf"

	test -d "${CHROOT_DIR}/etc" || \
		mkdir -p "${CHROOT_DIR}/etc"

	echo "# OpenSLX bootstrap configuration file" >"${CONFIG_FILE}"

	for key in \
		SLX_BASE_BOOTSTRAP_PACKAGES \
		SLX_BASE_PREREQ_PACKAGES \
		SLX_BOOTSTRAP_FAIL_WGET \
		SLX_STAGE1_FINAL_PATH \
		SLX_INST_ARCH \
		SLX_INST_SOURCE_BASEURL \
		SLX_INST_SOURCE_DISTRIBUTION \
		SLX_INST_SOURCE_PACKAGEKEYS \
		SLX_INST_SOURCE_PACKAGE_SUBDIR; do
		value=$( eval echo \$$key)
		test "${value}" || \
			continue
		echo $key=\"$value\" >>"${CONFIG_FILE}"
	done

	test -d "${CHROOT_DIR}/bin" || \
		mkdir -p "${CHROOT_DIR}/bin"
	cp -p "${SLX_SHARE_PATH}"/busybox/slx* "${CHROOT_DIR}/bin"
}

function setup_busybox_install_prereq_file()
{
	if test -d "${SLX_SYSTEM_CONFIG_PATH}/prereqfiles"; then
		test -d "${CHROOT_DIR}/etc/prereqfiles/" || \
			mkdir -p "${CHROOT_DIR}/etc/prereqfiles/"
		cp -pr "${SLX_SYSTEM_CONFIG_PATH}"/prereqfiles/* "${CHROOT_DIR}/etc/prereqfiles/"
		find "${SLX_STAGE1_PATH}" -type d -name .svn -print0 | \
			xargs -0 rm -rf
	fi
	if test -x "${SLX_SYSTEM_CONFIG_PATH}/scripts/postprereq"; then
		test -d "${CHROOT_DIR}/bin" ||
			mkdir -p "${CHROOT_DIR}/bin"
		cp -p "${SLX_SYSTEM_CONFIG_PATH}"/scripts/postprereq "${CHROOT_DIR}/bin/"
	fi
}

function setup_bootstrap_1b()
{
	chroot "${CHROOT_DIR}" /bin/slxbootstrap
	if test $? != 0; then
		echo "$0: Error while calling /bin/slxbootstrap inside chroot, ${CHROOT_DIR}. "
		exit 1
	fi
}

function setup_bootstrap_1c()
{
	local dir file packagekey	

	case "${SLX_SYSTEM_BASENAME}" in
		*ubuntu*)
			test -d "${SLX_STAGE1_FINAL_PATH}" || \
				mkdir -p "${SLX_STAGE1_FINAL_PATH}"

			DEBOOTSTRAP_DIR="${SLX_BOOTSTRAP_PATH}/usr/lib/debootstrap" \
			chroot "${CHROOT_DIR}" /bin/ash \
			"${SLX_BOOTSTRAP_PATH}/usr/sbin/debootstrap" \
				${SLX_INST_ARCH:+--arch $SLX_INST_ARCH} \
				"${SLX_INST_SOURCE_DISTRIBUTION}" \
				"${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}" \
				"${SLX_INST_SOURCE_BASEURL}"
		;;
		*suse*|*fedora*)
			test -d "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/etc" || \
				mkdir "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/etc"
			touch "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/etc/mtab"
			for file in ${SLX_INSTALL_FAKE_FILE}; do
				dir="${file%/*}"
				test -d "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}/${dir}" || \
					mkdir -p "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}/${dir}"
				touch "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}/${file}"
			done
			for packagekey in ${SLX_INST_SOURCE_PACKAGEKEYS}; do
				chroot "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}" \
					/bin/rpm --root="${SLX_STAGE1_FINAL_PATH}" --import "${packagekey}"
			done
			chroot "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}" \
				/bin/rpm --root="${SLX_STAGE1_FINAL_PATH}" -ivh *.rpm
			cp -p /etc/resolv.conf "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}/etc/"
		;;
	esac
	mv "${CHROOT_DIR}/${SLX_BOOTSTRAP_PATH}/${SLX_STAGE1_FINAL_PATH}/"* "${SLX_STAGE1_PATH}/"
	rm -rf ${CHROOT_DIR}
}

function setup_package_sources()
{
	case "${SLX_SYSTEM_BASENAME}" in
		*ubuntu*)
			SOURCES_LIST="${SLX_STAGE1_PATH}/etc/apt/sources.list"
			rm -f "${SOURCES_LIST}"
		;;
		*fedora*)
			rm -f "${SLX_STAGE1_PATH}/etc/yum.repos.d/"*
		;;
	esac

	# Add available installation sources to an installed system.
	# For systems using apt we're able to do this from outside.
	for variable in ${!SLX_INST_SOURCE_NAME_*}; do
		# Unset INST_SOURCE_* to let the meta packager fail if they are not set for a particular
		# channel; unset PACKAGEKEYS to prevent adding them multiple times.
		unset INST_SOURCE_COMPONENTS \
			INST_SOURCE_DISTRIBUTION \
			INST_SOURCE_NAME \
			INST_SOURCE_PRIORITY \
			INST_SOURCE_REPO_SUBDIR \
			INST_SOURCE_TYPE \
			PACKAGEKEYS

		INST_SOURCE_CHANNEL="${variable##*_}"
		INST_SOURCE_BASEURL=$( eval echo \$SLX_INST_SOURCE_BASEURL_${INST_SOURCE_CHANNEL})
		INST_SOURCE_NAME=$( eval echo \$$variable)
		test "${INST_SOURCE_NAME}" || \
			INST_SOURCE_NAME="${INST_SOURCE_CHANNEL}"

		INST_SOURCE_REPO_SUBDIR=$( eval echo \$SLX_INST_SOURCE_REPO_SUBDIR_${INST_SOURCE_CHANNEL})
		INST_SOURCE_TYPE=$( eval echo \$SLX_INST_SOURCE_TYPE_${INST_SOURCE_CHANNEL})
		# Use default repo type if not available from settings config file
		test "${INST_SOURCE_TYPE}" || \
			INST_SOURCE_TYPE="${REPO_TYPE}"

		# Has this config distribution, components
		INST_SOURCE_DISTRIBUTION=$( eval echo \$SLX_INST_SOURCE_DISTRIBUTION_${INST_SOURCE_CHANNEL})
		INST_SOURCE_COMPONENTS=$( eval echo \$SLX_INST_SOURCE_COMPONENTS_${INST_SOURCE_CHANNEL})
		INST_SOURCE_PRIORITY=$( eval echo \$SLX_INST_SOURCE_PRIORITY_${INST_SOURCE_CHANNEL})
		# Check if one of our global settings is still undefined
		for setting in ${GLOBAL_SETTINGS}; do
			test "$( eval echo \$INST_SOURCE_${setting})" || \
				eval INST_SOURCE_${setting}=\$SLX_INST_SOURCE_${setting}
		done

		echo "$0: Adding installation source name=\"${INST_SOURCE_NAME}\", baseurl=\"${INST_SOURCE_BASEURL}${INST_SOURCE_REPO_SUBDIR:+/${INST_SOURCE_REPO_SUBDIR}}\". "

		case "${META_PACKAGER}" in
			*ubuntu*)
				echo "deb ${INST_SOURCE_BASEURL} ${INST_SOURCE_DISTRIBUTION} ${INST_SOURCE_COMPONENTS}" \
					>>${SOURCES_LIST}
				# FIXME Add feature to sort the lines by given (?) priority.
			;;
			*suse*)
				# Prefix the config name for optional parameters
				test "${INST_SOURCE_PRIORITY}" && \
					INST_SOURCE_PRIORITY="priority=\"${INST_SOURCE_PRIORITY}\""

				eval LC_ALL=POSIX chroot ${SLX_STAGE1_PATH} smart \
					channel \
					--add \"${INST_SOURCE_CHANNEL}\" \
					name=\"${INST_SOURCE_NAME}\" \
					type=\"${INST_SOURCE_TYPE}\" \
					baseurl=\"${INST_SOURCE_BASEURL}\" \
					${INST_SOURCE_PRIORITY} \
					-y
			;;
			yum|*fedora*)
				echo -e "[${INST_SOURCE_CHANNEL}]\nname=${INST_SOURCE_NAME}\nbaseurl=${INST_SOURCE_BASEURL}${INST_SOURCE_REPO_SUBDIR:+/${INST_SOURCE_REPO_SUBDIR}}" \
					>${SLX_STAGE1_PATH}/etc/yum.repos.d/${INST_SOURCE_CHANNEL}.repo
			;;
		esac
	done
}

# Install all available updates for an installed system.
# Before we have to ensure to have the install sources up to date.
function update_system()
{
	if test -z "${SLX_STAGE1_PATH}"; then
		echo "Error: SLX_STAGE1_PATH is not set."
		exit 1
	fi

	case "${META_PACKAGER}" in
		*ubuntu*)
			: ${SLX_STAGE1_UPDATE_OPTIONS:=-y}
			: ${SLX_STAGE1_UPGRADE_OPTIONS:=-y}
			chroot "${SLX_STAGE1_PATH}" apt-get update ${SLX_STAGE1_UPDATE_OPTIONS}
			chroot "${SLX_STAGE1_PATH}" apt-get upgrade ${SLX_STAGE1_UPGRADE_OPTIONS}
		;;
		*suse*)
			: ${SLX_STAGE1_UPGRADE_OPTIONS:=-y}
			LC_ALL=POSIX chroot "${SLX_STAGE1_PATH}" smart upgrade --update ${SLX_STAGE1_UPGRADE_OPTIONS}
		;;
		yum|*fedora*)
			: ${SLX_STAGE1_UPDATE_OPTIONS:=-y}
			cp -p /proc/cpuinfo "${SLX_STAGE1_PATH}/proc/cpuinfo"
			LC_ALL=POSIX chroot "${SLX_STAGE1_PATH}" yum ${SLX_STAGE1_UPDATE_OPTIONS} update
			rm "${SLX_STAGE1_PATH}/proc/cpuinfo"
		;;
	esac
}

function install_slxselection()
{
	if test -z "${SLX_STAGE1_PATH}"; then
		echo "Error: SLX_STAGE1_PATH is not set."
		exit 1
	fi

	local packagelist variable
	for variable in ${!SLX_INSTALL_PACKAGES_*}; do
		packages=$( eval echo \$$variable)
		packagelist="${packagelist:+$packagelist }$( eval echo \$$variable)"
	done
	test -z "${packagelist}" && \
		return
	
	case "${META_PACKAGER}" in
		*ubuntu*)
			: ${SLX_STAGE1_INSTALL_OPTIONS:=-y}
			chroot "${SLX_STAGE1_PATH}" apt-get install ${SLX_STAGE1_INSTALL_OPTIONS} ${packagelist}
		;;
		*suse*)
			: ${SLX_STAGE1_INSTALL_OPTIONS:=-y}
			LC_ALL=POSIX chroot "${SLX_STAGE1_PATH}" smart install ${SLX_STAGE1_INSTALL_OPTIONS} ${packagelist}
		;;
		yum|*fedora*)
			: ${SLX_STAGE1_INSTALL_OPTIONS:=-y}
			cp -p /proc/cpuinfo "${SLX_STAGE1_PATH}/proc/cpuinfo"
			LC_ALL=POSIX chroot "${SLX_STAGE1_PATH}" yum ${SLX_STAGE1_INSTALL_OPTIONS} install ${packagelist}
			rm "${SLX_STAGE1_PATH}/proc/cpuinfo"
		;;
	esac
}

function slxossetup_busybox()
{
	local CHROOT_DIR

	setup_busybox_init
	if test -z "${SLX_STAGE1_PATH}" -o -z "${SLX_BUSYBOX_CHROOT_NAME}"; then
		echo "Error: SLX_STAGE1_PATH or SLX_BUSYBOX_CHROOT_NAME is not set."
		exit 1
	fi
	CHROOT_DIR="${SLX_STAGE1_PATH}/${SLX_BUSYBOX_CHROOT_NAME}"
	setup_busybox_chroot
	setup_busybox_stage1_config
	setup_busybox_install_prereq_file

	setup_bootstrap_1b
	setup_bootstrap_1c

	setup_package_sources
	update_system
	install_slxselection
}

function install_prereq_packages()
{
	test "${SLX_BASE_PREREQ_PACKAGES}" || \
		return

	# Download and unpack prerequired packages before any package installation
	SLX_PACKAGE_PATH="${SLX_METADATA_PATH}/packages"
	TMP_DIR=$( mktemp -d "${SLX_METADATA_PATH}/packages.XXXXXXXX")
	if test $? -ne 0; then
		echo "$0: Warning, can not create temp package download directory! "
		echo "    Using ${SLX_PACKAGE_DOWNLOAD_PATH} instead. "
		SLX_PACKAGE_DOWNLOAD_PATH="${SLX_PACKAGE_PATH}"
	else
		SLX_PACKAGE_DOWNLOAD_PATH="${TMP_DIR}"
	fi
	test -d "${SLX_PACKAGE_DOWNLOAD_PATH}" || \
		mkdir -p "${SLX_PACKAGE_DOWNLOAD_PATH}"
	pushd "${SLX_PACKAGE_DOWNLOAD_PATH}" >/dev/null
	smart --data-dir="${SLX_METADATA_PATH}" \
		download \
		${SLX_BASE_PREREQ_PACKAGES}

	unset packagelist
	for package in ${SLX_BASE_PREREQ_PACKAGES}; do
		packagelist="${packagelist} $( ls ${package}*)"
	done
	popd >/dev/null

	ARCHIVES_PATH="${SLX_METADATA_PATH}/deb-archives"
	BOOTSTRAP_PATH="${SLX_METADATA_PATH}/debootstrap"
	test -d "${SLX_STAGE1_PATH}" || \
		mkdir -p "${SLX_STAGE1_PATH}"
	for package in ${packagelist}; do
		package="${SLX_PACKAGE_DOWNLOAD_PATH}/${package}"
		case "${package}" in
			*.deb)
				test -d "${ARCHIVES_PATH}" || \
					mkdir -p "${ARCHIVES_PATH}"
				test -d "${BOOTSTRAP_PATH}" || \
					mkdir -p "${BOOTSTRAP_PATH}"
				pushd "${ARCHIVES_PATH}" >/dev/null
				ar x "${package}"
				popd >/dev/null
				pushd "${BOOTSTRAP_PATH}" >/dev/null
				tar xfz "${ARCHIVES_PATH}/data.tar.gz"
				popd >/dev/null
				rm -rf "${ARCHIVES_PATH}"
				;;
			*.rpm)
				pushd "${SLX_STAGE1_PATH}" >/dev/null
				rpm2cpio "${package}" | \
					cpio -i --make-directories
				popd >/dev/null
				;;
			*)
				echo "$0: Warning, unknown package type of ${package}. "
				;;
		esac
	done

	# Ckech if we have to bootstrap
	if test "${BOOTSTRAP_PATH}" -a -x "${BOOTSTRAP_PATH}/usr/sbin/debootstrap"; then
		DEBOOTSTRAP_DIR="${BOOTSTRAP_PATH}/usr/lib/debootstrap" \
			"${BOOTSTRAP_PATH}/usr/sbin/debootstrap" \
			${SLX_INST_ARCH:+--arch $SLX_INST_ARCH} \
			"${SLX_INST_SOURCE_DISTRIBUTION}" \
			"${SLX_STAGE1_PATH}" \
			"${SLX_INST_SOURCE_BASEURL}"
		rm -rf "${BOOTSTRAP_PATH}"
	fi

	# Move package from temp to package dir.
	if test "${SLX_PACKAGE_DOWNLOAD_PATH}" != "${SLX_PACKAGE_PATH}"; then
		test -d "${SLX_PACKAGE_PATH}" || \
			mkdir -p "${SLX_PACKAGE_PATH}"
		pushd "${SLX_PACKAGE_DOWNLOAD_PATH}" >/dev/null
		for package in *.deb *.rpm; do
			test -f ${package} || \
				continue
			mv ${package} "${SLX_PACKAGE_PATH}"
		done
		popd >/dev/null
		rmdir "${SLX_PACKAGE_DOWNLOAD_PATH}"
	fi

	# Cleanup etc to prevent .rpnnew files
	if test "${SLX_BASE_PREREQ_CLEANUP_PATH}"; then
		for path in ${SLX_BASE_PREREQ_CLEANUP_PATH}; do
			find "${SLX_STAGE1_PATH}/${path}" -type f -print0 | \
				xargs -0 rm -f
		done
	fi
}

function slxossetup_smart()
{
	for dir in ${SLX_METADATA_PATH} ${SLX_STAGE1_PATH}; do
		if test -d "${dir}"; then
			echo "$0: Error, ${dir} already exists! "
			exit 1
		fi
	done

	smart --data-dir="${SLX_METADATA_PATH}" \
		config \
		--set \
		"${NAME_DEST_ROOT}"="${SLX_STAGE1_PATH}"

	for variable in ${!SLX_INST_SOURCE_NAME_*}; do
		# Unset SMART_* to let smart fail if they are not set for a particular
		# channel; unset PACKAGEKEYS to prevent adding them multiple times.
		unset SMART_COMPONENTS \
			SMART_DISTRIBUTION \
			SMART_NAME \
			SMART_PRIORITY \
			SMART_TYPE \
			PACKAGEKEYS

		SMART_CHANNEL="${variable##*_}"
		SMART_BASEURL=$( eval echo \$SLX_INST_SOURCE_BASEURL_${SMART_CHANNEL})
		SMART_NAME=$( eval echo \$$variable)
		test "${SMART_NAME}" || \
			SMART_NAME="${SMART_CHANNEL}"

		SMART_TYPE=$( eval echo \$SLX_INST_SOURCE_TYPE_${SMART_CHANNEL})
		# Use default repo type if not available from settings config file
		test "${SMART_TYPE}" || \
			SMART_TYPE="${REPO_TYPE}"

		# Has this config distribution, components
		SMART_DISTRIBUTION=$( eval echo \$SLX_INST_SOURCE_DISTRIBUTION_${SMART_CHANNEL})
		SMART_COMPONENTS=$( eval echo \$SLX_INST_SOURCE_COMPONENTS_${SMART_CHANNEL})
		SMART_PRIORITY=$( eval echo \$SLX_INST_SOURCE_PRIORITY_${SMART_CHANNEL})
		# Check if one of our global settings is still undefined
		for setting in ${GLOBAL_SETTINGS}; do
			test "$( eval echo \$SMART_${setting})" || \
				eval SMART_${setting}=\$SLX_INST_SOURCE_${setting}
		done

		# Prefix the config name for optional parameters
		test "${SMART_DISTRIBUTION}" && \
		SMART_DISTRIBUTION="distribution=\"${SMART_DISTRIBUTION}\""
		test "${SMART_COMPONENTS}" && \
			SMART_COMPONENTS="components=\"${SMART_COMPONENTS}\""
		test "${SMART_PRIORITY}" && \
			SMART_PRIORITY="priority=\"${SMART_PRIORITY}\""

		PACKAGEKEYS=$( eval echo \$SLX_INST_SOURCE_PACKAGEKEYS_${SMART_CHANNEL})

		eval smart --data-dir=\"${SLX_METADATA_PATH}\" \
			channel \
			--add \"${SMART_CHANNEL}\" \
			name=\"${SMART_NAME}\" \
			type=\"${SMART_TYPE}\" \
			baseurl=\"${SMART_BASEURL}\" \
			${SMART_DISTRIBUTION} \
			${SMART_COMPONENTS} \
			${SMART_PRIORITY} \
			-y

		for packagekey in ${PACKAGEKEYS}; do
			case "${packagekey}" in
				*/*) ;;
				*) packagekey="${SMART_BASEURL}/${packagekey}" ;;
			esac
			rpm --root="${SLX_STAGE1_PATH}" \
				--import "${packagekey}"
		done
	done

	for path in ${SLX_STAGE1_CREATE_DIR}; do
		mkdir -p "${SLX_STAGE1_PATH}/${path}"
	done
	for file in ${SLX_STAGE1_CREATE_FILE}; do
		touch "${SLX_STAGE1_PATH}/${file}"
	done

	smart --data-dir="${SLX_METADATA_PATH}" \
		update

	install_prereq_packages

	install_prereq_file

	for mountpoint in ${SLX_INSTALL_BIND_MOUNT}; do
		test -d "${SLX_STAGE1_PATH}/${mountpoint}" || \
			mkdir -p "${SLX_STAGE1_PATH}/${mountpoint}"
		mount -o bind "/${mountpoint}" "${SLX_STAGE1_PATH}/${mountpoint}"
	done

	unset packagelist
	for variable in ${!SLX_INSTALL_PACKAGES_*}; do
		packagelist="${packagelist} $( eval echo \$$variable)"
	done

	smart --data-dir="${SLX_METADATA_PATH}" \
		install \
		${packagelist} \
		-y

	# Move any .rpmnew file to the right name
	for file in $( find "${SLX_STAGE1_PATH}" -type f -name '*.rpmnew'); do
		mv "${file}" "${file%.rpmnew}"
	done

	for mountpoint in ${SLX_INSTALL_BIND_MOUNT}; do
		umount "${SLX_STAGE1_PATH}/${mountpoint}"
	done
	
	for file in ${SLX_INSTALL_FAKE_FILE}; do
		test -s "${SLX_STAGE1_PATH}/${file}" || \
			rm -f "${SLX_STAGE1_PATH}/${file}"
	done
}

function slxossetup_init()
{
	SLX_METADATA_PATH="${SLX_PRIVATE_PATH}/metadata/${SLX_SYSTEM_NAME}"
	SLX_STAGE1_PATH="${SLX_PRIVATE_PATH}/stage1/${SLX_SYSTEM_NAME}"
}

function slxossetup()
{
	slxossetup_init

	case "${SLX_SYSTEM_BASENAME}" in
		*suse*)
			# Inform SUSE RPMs that we're performing an installation
			# This is only important in stage 1c
			export YAST_IS_RUNNING="instsys"
			GLOBAL_SETTINGS="BASEURL PACKAGEKEYS"
			REPO_TYPE="rpm-md"
			NAME_DEST_ROOT="rpm-root"
			;;
		*fedora*)
			GLOBAL_SETTINGS="BASEURL PACKAGEKEYS"
			REPO_TYPE="rpm-md"
			NAME_DEST_ROOT="rpm-root"
			;;
		*ubuntu*)
			GLOBAL_SETTINGS="BASEURL COMPONENTS DISTRIBUTION"
			REPO_TYPE="apt-deb"
			NAME_DEST_ROOT="deb-root"
			SLX_STAGE1_CREATE_DIR="/var/lib/dpkg/updates"
			SLX_STAGE1_CREATE_FILE="/var/lib/dpkg/available /var/lib/dpkg/status"
			;;
		*) echo "$0: Error, unkown system ${SLX_SYSTEM_BASENAME}" ;;
	esac

	test "${SLX_META_PACKAGER}" && \
		META_PACKAGER="${SLX_META_PACKAGER}" || \
		META_PACKAGER="${SLX_SYSTEM_BASENAME}"

	case "${SLX_OSSETUP_MODE}" in
		bootstrap) slxossetup_busybox ;;
		package-source) setup_package_sources ;;
		install-selection) install_slxselection ;;
	esac
}

case "${SLX_OSSETUP_MODE}" in
	bootstrap|package-source|install-selection) slxossetup ;;
	*) echo "Usage: $0 system-name [bootstrap|package-source|install-selection]" ;;
esac