lib/mage/convert_databases_smage.sh

#!/bin/bash

source /etc/mage.rc.global
source /etc/mage.rc


#### fixups ####
MLIBDIR=/home/tjoke/svn/magellan-source/branches/mage-sql/usr/lib/mage
INSTALLDB=/var/db/mage
#################

source ${MLIBDIR}/mage4.functions.sh
source ${MLIBDIR}/sql_functions.sh

die()
{
	echo -e "Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."
	echo -e "$@"
	exit 1
}

sql()
{
	local sqlcmd="$*"
	[[ -z ${sqlcmd} ]] && die "no sqlcmd given."

	sqlite3 -nullvalue 'NULL' -list -separator '|' ${DBFILE} << EOF || die "error running '$@'"
${sqlcmd};
EOF
}

split_save_variables()
{
	export SAVED_PNAME="${PNAME}"
	export SAVED_PVER="${PVER}"
	export SAVED_PBUILD="${PBUILD}"
	export SAVED_PCATEGORIE="${PCATEGORIE}"
	export SAVED_DESCRIPTION="${DESCRIPTION}"
	export SAVED_HOMEPAGE="${HOMEPAGE}"
	export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
	export SAVED_STATE="${STATE}"
	export SAVED_PKGTYPE="${PKGTYPE}"
	export SAVED_INHERITS="${INHERITS}"
	export SAVED_DEPEND="${DEPEND}"
	export SAVED_SDEPEND="${SDEPEND}"
	export SAVED_PROVIDE="${PROVIDE}"
	export SAVED_NOPKGBUILD="${NOPKGBUILD}"

	# bindir too
	export SAVED_BINDIR="${BINDIR}"

	# export the SPLIT_PACKAGE_BASE
	export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"

	# functions
	if [[ ! -z $(typeset -f preinstall) ]]
	then
		# rename the old one
		local saved_preinstall
		saved_preinstall=SAVED_$(typeset -f preinstall)
		eval "${saved_preinstall}"
		export -f SAVED_preinstall
	fi

	if [[ ! -z $(typeset -f postinstall) ]]
	then
		# rename the old one
		local saved_postinstall
		saved_postinstall=SAVED_$(typeset -f postinstall)
		eval "${saved_postinstall}"
		export -f SAVED_postinstall
	fi

	if [[ ! -z $(typeset -f preremove) ]]
	then
		# rename the old one
		local saved_preremove
		saved_preremove=SAVED_$(typeset -f preremove)
		eval "${saved_preremove}"
		export -f SAVED_preremove
	fi

	if [[ ! -z $(typeset -f postremove) ]]
	then
		# rename the old one
		local saved_postremove
		saved_postremove=SAVED_$(typeset -f postremove)
		eval "${saved_postremove}"
		export -f SAVED_postremove
	fi
}

split_restore_variables()
{
	export PNAME="${SAVED_PNAME}"
	export PVER="${SAVED_PVER}"
	export PBUILD="${SAVED_PBUILD}"
	export PCATEGORIE="${SAVED_PCATEGORIE}"
	export DESCRIPTION="${SAVED_DESCRIPTION}"
	export HOMEPAGE="${SAVED_HOMEPAGE}"
	export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
	export STATE="${SAVED_STATE}"
	export PKGTYPE="${SAVED_PKGTYPE}"
	export INHERITS="${SAVED_INHERITS}"
	export DEPEND="${SAVED_DEPEND}"
	export SDEPEND="${SAVED_SDEPEND}"
	export PROVIDE="${SAVED_PROVIDE}"
	export NOPKGBUILD="${SAVED_NOPKGBUILD}"

	# bindir too
	export BINDIR="${SAVED_BINDIR}"

	# functions
	if [[ ! -z $(typeset -f SAVED_preinstall) ]]
	then
		# rename the old one
		local saved_preinstall
		saved_preinstall=$(typeset -f SAVED_preinstall)
		eval "${saved_preinstall/SAVED_/}"
		export -f preinstall
	fi

	if [[ ! -z $(typeset -f SAVED_postinstall) ]]
	then
		# rename the old one
		local saved_postinstall
		saved_postinstall=$(typeset -f SAVED_postinstall)
		eval "${saved_postinstall/SAVED_/}"
		export -f postinstall
	fi

	if [[ ! -z $(typeset -f SAVED_preremove) ]]
	then
		# rename the old one
		local saved_preremove
		saved_preremove=$(typeset -f SAVED_preremove)
		eval "${saved_preremove/SAVED_/}"
		export -f preremove
	fi

	if [[ ! -z $(typeset -f SAVED_postremove) ]]
	then
		# rename the old one
		local saved_postremove
		saved_postremove=$(typeset -f SAVED_postremove)
		eval "${saved_postremove/SAVED_/}"
		export -f postremove
	fi
}

split_unset_variables()
{
	# unset saved vars; not needed anymore
	unset SAVED_PNAME
	unset SAVED_PVER
	unset SAVED_PBUILD
	unset SAVED_PCATEGORIE
	unset SAVED_DESCRIPTION
	unset SAVED_HOMEPAGE
	unset SAVED_SPECIAL_VARS
	unset SAVED_STATE
	unset SAVED_PKGTYPE
	unset SAVED_INHERITS
	unset SAVED_DEPEND
	unset SAVED_SDEPEND
	unset SAVED_PROVIDE
	unset SAVED_BINDIR
	unset SAVED_NOPKGBUILD
	unset SPLIT_PACKAGE_BASE
	unset -f SAVED_preinstall
	unset -f SAVED_postinstall
	unset -f SAVED_preremove
	unset -f SAVED_postremove
}

create_database_layout()
{
	sql "create table categories(id integer primary key, pcat text unique)"
	sql "create table packages(id integer primary key,
					pname text,
					pver text,
					pbuild text,
					pcat_id numeric,
					state text,
					provide text,
					pkgtype text
				)"
	sql "create table depends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
	sql "create table sdepends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
	sql "create table packages_info(id integer primary key, pkg_id numeric, arch text, md5 text, mtime numeric, homepage text, description text, size numeric)"
	#sql "create table packages_content(id integer primary key, pkginfo_id numeric, char text, dirs text, files text, pipes text, symlinks text)"
	sql "create table packages_content(id integer primary key, pkginfo_id numeric, char blob, dirs blob, files blob, pipes blob, symlinks blob)"
# 	sql "create table packages_routines(id integer primary key,
# 					pkg_id numeric,
# 					mincludes text,
# 					preinstall text,
# 					postinstall text,
# 					preremove text,
# 					postremove text,
# 					extra_functions text,
# 					extra_vars text)"
	sql "create table packages_routines(id integer primary key,
					pkg_id numeric,
					mincludes text,
					preinstall numeric,
					postinstall numeric,
					preremove numeric,
					postremove numeric,
					script text)"
}

smage2sqlite()
{
	local i
	local pcatid
	local pkgid
	local dep
	local sym
	local depname
	local depver
	local depbuild
	local depcat
	local depcatid
	local md5file
	local md5sum

	pcatid=$(sql "select id from categories where pcat='${PCATEGORIE}'")

	sql "insert into packages(
				pname,
				pver,
				pbuild,
				pcat_id,
				state,
				provide,
				pkgtype
				)
			values(
				'${PNAME}',
				'${PVER}',
				'${PBUILD}',
				'${pcatid}',
				'${STATE}',
				'${PROVIDE}',
				'${PKGTYPE}'
				)"

	pkgid=$(sql "select id from packages where pname='${PNAME}' and pver='${PVER}' and pbuild='${PBUILD}'")

	# depends
	while read sym dep
	do
		# ignore scripts atm -FIXME!!!
		case ${sym} in
			\$\(*) continue ;;
		esac

		[[ -z ${dep} ]] && continue
		depcat="$(dep2pcat ${dep})"
		depcatid=$(sql "select id from categories where pcat='${depcat}'")
		depname="$(dep2pname ${dep})"
		depver="$(dep2pver ${dep})"

		if [[ -z ${depcatid} ]]
		then
			die "Error: '${PNAME}' -> depcat '${depcat}' has no depcatid, it does no exist in database!"
		fi

		sql "insert into depends(pkg_id,
					relation,
					pcat_id,
					pname,
					pver,
					pbuild)
				values('${pkgid}',
					'${sym}',
					'${depcatid}',
					'${depname}',
					'${depver}',
					'${depbuild}')"
	done << EOF
${DEPEND}
EOF
	# sdepends
	while read sym dep
	do
		[[ -z ${dep} ]] && continue
		depcat="$(dep2pcat ${dep})"
		depcatid=$(sql "select id from categories where pcat='${depcat}'")
		depname="$(dep2pname ${dep})"
		depver="$(dep2pver ${dep})"
		sql "insert into sdepends(pkg_id,
					relation,
					pcat_id,
					pname,
					pver,
					pbuild)
				values('${pkgid}',
					'${sym}',
					'${depcatid}',
					'${depname}',
					'${depver}',
					'${depbuild}')"
	done << EOF
${SDEPEND}
EOF

	for arch in i686 x86_64
	do
		md5file="${MAGEDIR}/${PCATEGORIE}/${PNAME}/md5/${PNAME}-${PVER}-${arch}-r${PBUILD}.md5"
		[[ -f ${md5file} ]] && md5sum="$(cat ${md5file} | cut -d' ' -f1)"

		# fix descriptions
		DESCRIPTION="$(echo ${DESCRIPTION} | sed s:\':\'\':g)"

		sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
			values('${pkgid}','${arch}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
	done

	# using $INHERITS directly
	#mincludes="$(grep -r 'minclude ' ${magefile} | cut -d: -f2 | sed s:minclude\ ::)" 

# # 	#
# # 	# install routines & includes
# # 	#
# # 	# needs special magic: the last line of typeset has no ';'
# # 	# but to eval the function we must append it
# # 	# so this sed deletes the last line of the typeset output
# # 	# and replaces it with an ;} and a newline between
# # 	#
# # 	# but we will not add this fun when no postinstall etc are given
# # 	# -> [[ -n $(typeset -f postinstall ]] &&
# # 	#
# # 	# also the character ' is a problem while importing to sql
# # 	# because we use ' as escape char. so we replace it with ''
# # 	#
# # 	# $([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall | sed s:\':\'\':g | sed '$d');\n}")
# # 	#
# # 	sql "insert into packages_routines(pkg_id,
# # 				mincludes,
# # 				postinstall,
# # 				preinstall,
# # 				preremove,
# # 				postremove)
# # 			values('${pkgid}',
# # 				'${mincludes}',
# # 				'$([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall | sed s:\':\'\':g | sed '$d');\n}")',
# # 				'$([[ -n $(typeset -f preinstall) ]] && echo -e "$(typeset -f preinstall | sed s:\':\'\':g | sed '$d');\n}")',
# # 				'$([[ -n $(typeset -f preremove) ]] && echo -e "$(typeset -f preremove | sed s:\':\'\':g | sed '$d');\n}")',
# # 				'$([[ -n $(typeset -f postremove) ]] && echo -e "$(typeset -f postremove | sed s:\':\'\':g | sed '$d');\n}")')"

	local do_preinst=0
	local do_postinst=0
	local do_prerm=0
	local do_postrm=0
	local do_script=0
	local script=""

	[[ -n $(typeset -f preinstall) ]] && do_preinst=1 && do_script=1
	[[ -n $(typeset -f postinstall) ]] && do_postinst=1 && do_script=1
	[[ -n $(typeset -f preremove) ]] && do_prerm=1 && do_script=1
	[[ -n $(typeset -f postremove) ]] && do_postrm=1 && do_script=1

	[[ ${do_script} = 1 ]] && script="$(basename ${DBFILE} .sql).routines/${pkgid}/routines.sh"

	sql "insert into packages_routines(pkg_id,
				mincludes,
				postinstall,
				preinstall,
				preremove,
				postremove,
				script)
			values('${pkgid}',
				'${INHERITS}',
				'${do_postinst}',
				'${do_pretinst}',
				'${do_prerm}',
				'${do_postrm}',
				'${script}')"

# create it only if do_script=1
if [[ ${do_script} = 1 ]]
then
	# create a routines script
	local routines=$(dirname ${DBFILE})/${script}
	install -d $(dirname ${routines})

	echo '#!/bin/sh' > ${routines}
	echo "# routines.sh script for ${pkgid}, ${PNAME}-${PVER}-${PBUILD}" >> ${routines}
	echo >> ${routines}


	# special functions and variables
	if [[ -n ${SPECIAL_VARS} ]]
	then
		local i
		for i in ${SPECIAL_VARS}
		do
			# being tricky here :)
			echo "${i}=\"$(eval echo \$${i})\"" >> ${routines}
		done
		echo  >> ${routines}
	fi

	# add special functions
	if [[ -n ${SPECIAL_FUNCTIONS} ]]
	then
		local i
		for i in ${SPECIAL_FUNCTIONS}
		do
			# add to mage (quotes needed !)
			typeset -f "${i}" >> ${routines}
			echo >> ${routines}
			# unset to be safe (quotes needed !)
			unset "${i}"
		done
		echo  >> ${routines}
	fi

	# postinstall and co
	for i in preinstall postinstall preremove postremove
	do
		if [[ -n $(typeset -f "${i}") ]]
		then
			typeset -f "${i}" >> ${routines}
			echo >> ${routines}
		fi
	done

	# create start logic
	echo >> ${routines}
	echo 'case $1 in' >> ${routines}
	echo '	preinstall) preinstall ;;' >> ${routines}
	echo '	postinstall) postinstall ;;' >> ${routines}
	echo '	preremove) preremove ;;' >> ${routines}
	echo '	postremove) postremove ;;' >> ${routines}
	echo 'esac' >> ${routines}
	echo >> ${routines}
fi

	unset PCATEGORIE
	unset PNAME
	unset PVER
	unset PBUILD
	unset STATE
	unset DESCRIPTION
	unset HOMEPAGE
	unset PKGTYPE
	unset PKGNAME
	unset DEPEND
	unset SDEPEND
	unset PROVIDE
	unset SPECIAL_VARS
	unset SPECIAL_FUNCTIONS
	unset INHERITS
	unset SPLIT_PACKAGES

	# unset these functions
	unset -f preinstall
	unset -f postinstall
	unset -f preremove
	unset -f postremove
}

categories2sqlite()
{
	local file="$1"

	if [[ ! -f ${file} ]]
	then
		echo "${file} does not exist, ignoring..."
		return 0
	fi

	echo "using categories from ${file}..."
	# create categories
	cat ${file} | while read pcat
	do
		case ${pcat} in
			include|profiles) continue;;
			\#*|"") continue ;;
		esac

		# "upsert"
		if [[ -z $(sql "select pcat from categories where pcat='${pcat}'") ]]
		then
			sql "insert into categories (pcat) values('${pcat}')"
		fi
	done
}

convert_smage_db()
{
	local smagefile

	local PCATEGORIE
	local PNAME
	local PVER
	local PBUILD
	local STATE
	local PKGNAME
	local DESCRIPTION
	local HOMEPAGE
	local DEPEND
	local SDEPEND
	local PROVIDE
	local PKGTYPE
	local SPLIT_PACKAGES
	local preinstall
	local postinstall
	local preremove
	local postremove

	# create categories - global
	categories2sqlite "${SMAGESCRIPTSDIR}/.known_categories"

	# create categories - repo specific
	categories2sqlite "${SMAGESCRIPTSDIR}/${REPO}/.known_categories"

	# create packages
	for smagefile in $(find ${SMAGESCRIPTSDIR}/${REPO} -type f -name \*.smage2 | sort)
	do
		case ${DEBUG} in
			1|true) echo "converting ${smagefile}" ;;
		esac

		source ${smagefile}

		# build several subpackages
		if [[ -n ${SPLIT_PACKAGES} ]]
		then
			split_save_variables
			for subpackage in ${SPLIT_PACKAGES}
			do
				echo "Running for subpackage '${subpackage}'..."

				# get the right variables for the split
				export PNAME="${subpackage}"
				split_info_${subpackage}

				smage2sqlite

				# restore smage environment
				split_restore_variables
			done
			# unset all saved smage variables
			split_unset_variables
		else
			smage2sqlite
		fi

		unset PCATEGORIE
		unset PNAME
		unset PVER
		unset PBUILD
		unset STATE
		unset DESCRIPTION
		unset HOMEPAGE
		unset PKGTYPE
		unset PKGNAME
		unset DEPEND
		unset SDEPEND
		unset PROVIDE
		unset SPECIAL_VARS
		unset SPECIAL_FUNCTIONS
		unset INHERITS
		unset SPLIT_PACKAGES

		# unset these functions
		unset -f preinstall
		unset -f postinstall
		unset -f preremove
		unset -f postremove
	done
}

convert_install_db()
{
	local i
	local magefile
	local pcat
	local pname
	local pver
	local pbuild
	local pcatid
	local state
	local preinstall
	local postinstall
	local preremove
	local postremove
	local pkgid
	local dep
	local PKGNAME
	local STATE
	local DESCRIPTION
	local HOMEPAGE
	local DEPEND
	local SDEPEND
	local PROVIDE
	local PKGTYPE
	local preinstall
	local postinstall
	local preremove
	local postremove
	local sym
	local depname
	local depver
	local depbuild
	local depcat
	local depcatid
	local md5file
	local md5sum
	local pkginfoid
	local entrydir

	# first of all add virtual categorie
	sql "insert into categories(pcat) values('virtual')"

	# create categories
	for i in virtual ${INSTALLDB}/*
	do
		pcat="$(basename ${i})"
		case ${pcat} in
			include|profiles) continue;;
		esac

		sql "insert into categories (pcat) values('${pcat}')"
	done

	# create packages
	for magefile in $(find ${INSTALLDB} -type f -name *.mage| sort)
	do
		case ${DEBUG} in
			1|true) echo "converting ${magefile}" ;;
		esac

		pcat="$(magename2pcat ${magefile})"
		pname="$(magename2pname ${magefile})"
		pver="$(magename2pver ${magefile})"
		pbuild="$(magename2pbuild ${magefile})"

		source ${magefile}

		pcatid=$(sql "select id from categories where pcat='${pcat}'")
		sql "insert into packages(
					pname,
					pver,
					pbuild,
					pcat_id,
					state,
					provide,
					pkgtype
					)
				values(
					'${pname}',
					'${pver}',
					'${pbuild}',
					'${pcatid}',
					'${STATE}',
					'${PROVIDE}',
					'${PKGTYPE}'
					)"

		pkgid=$(sql "select id from packages where pname='${pname}' and pver='${pver}' and pbuild='${pbuild}'")
		# depends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into depends(pkg_id,
						relation,
						pcat_id,
						pname,
						pver,
						pbuild)
					values('${pkgid}',
						'${sym}',
						'${depcatid}',
						'${depname}',
						'${depver}',
						'${depbuild}')"
		done << EOF
${DEPEND}
EOF
		# sdepends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into sdepends(pkg_id,
						relation,
						pcat_id,
						pname,
						pver,
						pbuild)
					values('${pkgid}',
						'${sym}',
						'${depcatid}',
						'${depname}',
						'${depver}',
						'${depbuild}')"
		done << EOF
${SDEPEND}
EOF

		DESCRIPTION="$(echo ${DESCRIPTION} | sed s:\':\'\':g)"
		sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
			values('${pkgid}','${ARCH}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"


		# install routines & includes
		sql "insert into packages_routines(pkg_id,
					mincludes,
					postinstall,
					preinstall,
					preremove,
					postremove)
				values('${pkgid}',
					'${mincludes}',
					'$(typeset -f postinstall | sed s:\':\'\':g)',
					'$(typeset -f preinstall | sed s:\':\'\':g)',
					'$(typeset -f preremove | sed s:\':\'\':g)',
					'$(typeset -f postremove | sed s:\':\'\':g)')"

		####           ####
		# record contents #
		####           ####
		pkginfoid=$(sql "select id from packages_info where pkg_id='${pkgid}' and arch='${ARCH}'")
		entrydir="$(dirname ${magefile})"
		sql "insert into packages_content(pkginfo_id,
						char,
						dirs,
						files,
						pipes,
						symlinks)
					values('${pkginfoid}',
						'$(basename ${DBFILE} .sql).records/${pkginfoid}/char.bz2',
						'$(basename ${DBFILE} .sql).records/${pkginfoid}/dirs.bz2',
						'$(basename ${DBFILE} .sql).records/${pkginfoid}/files.bz2',
						'$(basename ${DBFILE} .sql).records/${pkginfoid}/pipes.bz2',
						'$(basename ${DBFILE} .sql).records/${pkginfoid}/symlinks.bz2')"
		# create compressed content files
		local entryfile
		for entryfile in char dirs files pipes symlinks
		do
			install -d $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}
			cat ${entrydir}/.${entryfile} | bzip2 -9 >> $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}/${entryfile}.bz2
		done

		unset PKGNAME
		unset DEPEND
		unset SDEPEND
		unset PROVIDE
		unset SPECIAL_VARS
		unset SPECIAL_FUNCTIONS

		# unset these functions
		unset -f preinstall
		unset -f postinstall
		unset -f preremove
		unset -f postremove
	done
}

convert_virtual_defaults()
{
	local virtual
	local package
	local vcat
	local vname
	local pcat
	local pname

	sql "create table virtual_defaults(id integer primary key, vcat text,vname text, pcat text, pname text)"

	while read virtual package
	do
		vcat="$(dirname ${virtual})"
		vname="$(basename ${virtual})"
		pcat="$(dirname ${package})"
		pname="$(basename ${package})"

		sql "insert into virtual_defaults(vcat,vname,pcat,pname) values('${vcat}','${vname}','${pcat}','${pname}')"
	done < /etc/mage-profile/virtuals.defaults
}

METHOD="$1"
DBFILE="$2"
REPO="$3"

[[ -z ${METHOD} ]] && die "No method given. Use --install, --packages or --virtual for your appropiate task"
[[ -z ${DBFILE} ]] && die "No database given."
[[ -z ${REPO} ]] && die "No repository given."

case $1 in
	--install|-i)
		create_database_layout
		convert_install_db
		;;
	--packages|-p)
		convert_virtual_defaults
		create_database_layout
		convert_smage_db
		;;
#	--virtuals|-v)
#		convert_virtual_defaults
#		;;
	*) die "Unkown method." ;;
esac
1	#!/bin/bash
2
3	source /etc/mage.rc.global
4	source /etc/mage.rc
5
6
7	#### fixups ####
8	MLIBDIR=/home/tjoke/svn/magellan-source/branches/mage-sql/usr/lib/mage
9	INSTALLDB=/var/db/mage
10	#################
11
12	source ${MLIBDIR}/mage4.functions.sh
13	source ${MLIBDIR}/sql_functions.sh
14
15	die()
16	{
17	echo -e "Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."
18	echo -e "$@"
19	exit 1
20	}
21
22	sql()
23	{
24	local sqlcmd="$*"
25	[[ -z ${sqlcmd} ]] && die "no sqlcmd given."
26
27	sqlite3 -nullvalue 'NULL' -list -separator '\|' ${DBFILE} << EOF \|\| die "error running '$@'"
28	${sqlcmd};
29	EOF
30	}
31
32	split_save_variables()
33	{
34	export SAVED_PNAME="${PNAME}"
35	export SAVED_PVER="${PVER}"
36	export SAVED_PBUILD="${PBUILD}"
37	export SAVED_PCATEGORIE="${PCATEGORIE}"
38	export SAVED_DESCRIPTION="${DESCRIPTION}"
39	export SAVED_HOMEPAGE="${HOMEPAGE}"
40	export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
41	export SAVED_STATE="${STATE}"
42	export SAVED_PKGTYPE="${PKGTYPE}"
43	export SAVED_INHERITS="${INHERITS}"
44	export SAVED_DEPEND="${DEPEND}"
45	export SAVED_SDEPEND="${SDEPEND}"
46	export SAVED_PROVIDE="${PROVIDE}"
47	export SAVED_NOPKGBUILD="${NOPKGBUILD}"
48
49	# bindir too
50	export SAVED_BINDIR="${BINDIR}"
51
52	# export the SPLIT_PACKAGE_BASE
53	export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
54
55	# functions
56	if [[ ! -z $(typeset -f preinstall) ]]
57	then
58	# rename the old one
59	local saved_preinstall
60	saved_preinstall=SAVED_$(typeset -f preinstall)
61	eval "${saved_preinstall}"
62	export -f SAVED_preinstall
63	fi
64
65	if [[ ! -z $(typeset -f postinstall) ]]
66	then
67	# rename the old one
68	local saved_postinstall
69	saved_postinstall=SAVED_$(typeset -f postinstall)
70	eval "${saved_postinstall}"
71	export -f SAVED_postinstall
72	fi
73
74	if [[ ! -z $(typeset -f preremove) ]]
75	then
76	# rename the old one
77	local saved_preremove
78	saved_preremove=SAVED_$(typeset -f preremove)
79	eval "${saved_preremove}"
80	export -f SAVED_preremove
81	fi
82
83	if [[ ! -z $(typeset -f postremove) ]]
84	then
85	# rename the old one
86	local saved_postremove
87	saved_postremove=SAVED_$(typeset -f postremove)
88	eval "${saved_postremove}"
89	export -f SAVED_postremove
90	fi
91	}
92
93	split_restore_variables()
94	{
95	export PNAME="${SAVED_PNAME}"
96	export PVER="${SAVED_PVER}"
97	export PBUILD="${SAVED_PBUILD}"
98	export PCATEGORIE="${SAVED_PCATEGORIE}"
99	export DESCRIPTION="${SAVED_DESCRIPTION}"
100	export HOMEPAGE="${SAVED_HOMEPAGE}"
101	export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
102	export STATE="${SAVED_STATE}"
103	export PKGTYPE="${SAVED_PKGTYPE}"
104	export INHERITS="${SAVED_INHERITS}"
105	export DEPEND="${SAVED_DEPEND}"
106	export SDEPEND="${SAVED_SDEPEND}"
107	export PROVIDE="${SAVED_PROVIDE}"
108	export NOPKGBUILD="${SAVED_NOPKGBUILD}"
109
110	# bindir too
111	export BINDIR="${SAVED_BINDIR}"
112
113	# functions
114	if [[ ! -z $(typeset -f SAVED_preinstall) ]]
115	then
116	# rename the old one
117	local saved_preinstall
118	saved_preinstall=$(typeset -f SAVED_preinstall)
119	eval "${saved_preinstall/SAVED_/}"
120	export -f preinstall
121	fi
122
123	if [[ ! -z $(typeset -f SAVED_postinstall) ]]
124	then
125	# rename the old one
126	local saved_postinstall
127	saved_postinstall=$(typeset -f SAVED_postinstall)
128	eval "${saved_postinstall/SAVED_/}"
129	export -f postinstall
130	fi
131
132	if [[ ! -z $(typeset -f SAVED_preremove) ]]
133	then
134	# rename the old one
135	local saved_preremove
136	saved_preremove=$(typeset -f SAVED_preremove)
137	eval "${saved_preremove/SAVED_/}"
138	export -f preremove
139	fi
140
141	if [[ ! -z $(typeset -f SAVED_postremove) ]]
142	then
143	# rename the old one
144	local saved_postremove
145	saved_postremove=$(typeset -f SAVED_postremove)
146	eval "${saved_postremove/SAVED_/}"
147	export -f postremove
148	fi
149	}
150
151	split_unset_variables()
152	{
153	# unset saved vars; not needed anymore
154	unset SAVED_PNAME
155	unset SAVED_PVER
156	unset SAVED_PBUILD
157	unset SAVED_PCATEGORIE
158	unset SAVED_DESCRIPTION
159	unset SAVED_HOMEPAGE
160	unset SAVED_SPECIAL_VARS
161	unset SAVED_STATE
162	unset SAVED_PKGTYPE
163	unset SAVED_INHERITS
164	unset SAVED_DEPEND
165	unset SAVED_SDEPEND
166	unset SAVED_PROVIDE
167	unset SAVED_BINDIR
168	unset SAVED_NOPKGBUILD
169	unset SPLIT_PACKAGE_BASE
170	unset -f SAVED_preinstall
171	unset -f SAVED_postinstall
172	unset -f SAVED_preremove
173	unset -f SAVED_postremove
174	}
175
176	create_database_layout()
177	{
178	sql "create table categories(id integer primary key, pcat text unique)"
179	sql "create table packages(id integer primary key,
180	pname text,
181	pver text,
182	pbuild text,
183	pcat_id numeric,
184	state text,
185	provide text,
186	pkgtype text
187	)"
188	sql "create table depends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
189	sql "create table sdepends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
190	sql "create table packages_info(id integer primary key, pkg_id numeric, arch text, md5 text, mtime numeric, homepage text, description text, size numeric)"
191	#sql "create table packages_content(id integer primary key, pkginfo_id numeric, char text, dirs text, files text, pipes text, symlinks text)"
192	sql "create table packages_content(id integer primary key, pkginfo_id numeric, char blob, dirs blob, files blob, pipes blob, symlinks blob)"
193	# sql "create table packages_routines(id integer primary key,
194	# pkg_id numeric,
195	# mincludes text,
196	# preinstall text,
197	# postinstall text,
198	# preremove text,
199	# postremove text,
200	# extra_functions text,
201	# extra_vars text)"
202	sql "create table packages_routines(id integer primary key,
203	pkg_id numeric,
204	mincludes text,
205	preinstall numeric,
206	postinstall numeric,
207	preremove numeric,
208	postremove numeric,
209	script text)"
210	}
211
212	smage2sqlite()
213	{
214	local i
215	local pcatid
216	local pkgid
217	local dep
218	local sym
219	local depname
220	local depver
221	local depbuild
222	local depcat
223	local depcatid
224	local md5file
225	local md5sum
226
227	pcatid=$(sql "select id from categories where pcat='${PCATEGORIE}'")
228
229	sql "insert into packages(
230	pname,
231	pver,
232	pbuild,
233	pcat_id,
234	state,
235	provide,
236	pkgtype
237	)
238	values(
239	'${PNAME}',
240	'${PVER}',
241	'${PBUILD}',
242	'${pcatid}',
243	'${STATE}',
244	'${PROVIDE}',
245	'${PKGTYPE}'
246	)"
247
248	pkgid=$(sql "select id from packages where pname='${PNAME}' and pver='${PVER}' and pbuild='${PBUILD}'")
249
250	# depends
251	while read sym dep
252	do
253	# ignore scripts atm -FIXME!!!
254	case ${sym} in
255	\$\(*) continue ;;
256	esac
257
258	[[ -z ${dep} ]] && continue
259	depcat="$(dep2pcat ${dep})"
260	depcatid=$(sql "select id from categories where pcat='${depcat}'")
261	depname="$(dep2pname ${dep})"
262	depver="$(dep2pver ${dep})"
263
264	if [[ -z ${depcatid} ]]
265	then
266	die "Error: '${PNAME}' -> depcat '${depcat}' has no depcatid, it does no exist in database!"
267	fi
268
269	sql "insert into depends(pkg_id,
270	relation,
271	pcat_id,
272	pname,
273	pver,
274	pbuild)
275	values('${pkgid}',
276	'${sym}',
277	'${depcatid}',
278	'${depname}',
279	'${depver}',
280	'${depbuild}')"
281	done << EOF
282	${DEPEND}
283	EOF
284	# sdepends
285	while read sym dep
286	do
287	[[ -z ${dep} ]] && continue
288	depcat="$(dep2pcat ${dep})"
289	depcatid=$(sql "select id from categories where pcat='${depcat}'")
290	depname="$(dep2pname ${dep})"
291	depver="$(dep2pver ${dep})"
292	sql "insert into sdepends(pkg_id,
293	relation,
294	pcat_id,
295	pname,
296	pver,
297	pbuild)
298	values('${pkgid}',
299	'${sym}',
300	'${depcatid}',
301	'${depname}',
302	'${depver}',
303	'${depbuild}')"
304	done << EOF
305	${SDEPEND}
306	EOF
307
308	for arch in i686 x86_64
309	do
310	md5file="${MAGEDIR}/${PCATEGORIE}/${PNAME}/md5/${PNAME}-${PVER}-${arch}-r${PBUILD}.md5"
311	[[ -f ${md5file} ]] && md5sum="$(cat ${md5file} \| cut -d' ' -f1)"
312
313	# fix descriptions
314	DESCRIPTION="$(echo ${DESCRIPTION} \| sed s:\':\'\':g)"
315
316	sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
317	values('${pkgid}','${arch}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
318	done
319
320	# using $INHERITS directly
321	#mincludes="$(grep -r 'minclude ' ${magefile} \| cut -d: -f2 \| sed s:minclude\ ::)"
322
323	# # #
324	# # # install routines & includes
325	# # #
326	# # # needs special magic: the last line of typeset has no ';'
327	# # # but to eval the function we must append it
328	# # # so this sed deletes the last line of the typeset output
329	# # # and replaces it with an ;} and a newline between
330	# # #
331	# # # but we will not add this fun when no postinstall etc are given
332	# # # -> [[ -n $(typeset -f postinstall ]] &&
333	# # #
334	# # # also the character ' is a problem while importing to sql
335	# # # because we use ' as escape char. so we replace it with ''
336	# # #
337	# # # $([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall \| sed s:\':\'\':g \| sed '$d');\n}")
338	# # #
339	# # sql "insert into packages_routines(pkg_id,
340	# # mincludes,
341	# # postinstall,
342	# # preinstall,
343	# # preremove,
344	# # postremove)
345	# # values('${pkgid}',
346	# # '${mincludes}',
347	# # '$([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall \| sed s:\':\'\':g \| sed '$d');\n}")',
348	# # '$([[ -n $(typeset -f preinstall) ]] && echo -e "$(typeset -f preinstall \| sed s:\':\'\':g \| sed '$d');\n}")',
349	# # '$([[ -n $(typeset -f preremove) ]] && echo -e "$(typeset -f preremove \| sed s:\':\'\':g \| sed '$d');\n}")',
350	# # '$([[ -n $(typeset -f postremove) ]] && echo -e "$(typeset -f postremove \| sed s:\':\'\':g \| sed '$d');\n}")')"
351
352	local do_preinst=0
353	local do_postinst=0
354	local do_prerm=0
355	local do_postrm=0
356	local do_script=0
357	local script=""
358
359	[[ -n $(typeset -f preinstall) ]] && do_preinst=1 && do_script=1
360	[[ -n $(typeset -f postinstall) ]] && do_postinst=1 && do_script=1
361	[[ -n $(typeset -f preremove) ]] && do_prerm=1 && do_script=1
362	[[ -n $(typeset -f postremove) ]] && do_postrm=1 && do_script=1
363
364	[[ ${do_script} = 1 ]] && script="$(basename ${DBFILE} .sql).routines/${pkgid}/routines.sh"
365
366	sql "insert into packages_routines(pkg_id,
367	mincludes,
368	postinstall,
369	preinstall,
370	preremove,
371	postremove,
372	script)
373	values('${pkgid}',
374	'${INHERITS}',
375	'${do_postinst}',
376	'${do_pretinst}',
377	'${do_prerm}',
378	'${do_postrm}',
379	'${script}')"
380
381	# create it only if do_script=1
382	if [[ ${do_script} = 1 ]]
383	then
384	# create a routines script
385	local routines=$(dirname ${DBFILE})/${script}
386	install -d $(dirname ${routines})
387
388	echo '#!/bin/sh' > ${routines}
389	echo "# routines.sh script for ${pkgid}, ${PNAME}-${PVER}-${PBUILD}" >> ${routines}
390	echo >> ${routines}
391
392
393	# special functions and variables
394	if [[ -n ${SPECIAL_VARS} ]]
395	then
396	local i
397	for i in ${SPECIAL_VARS}
398	do
399	# being tricky here :)
400	echo "${i}=\"$(eval echo \$${i})\"" >> ${routines}
401	done
402	echo >> ${routines}
403	fi
404
405	# add special functions
406	if [[ -n ${SPECIAL_FUNCTIONS} ]]
407	then
408	local i
409	for i in ${SPECIAL_FUNCTIONS}
410	do
411	# add to mage (quotes needed !)
412	typeset -f "${i}" >> ${routines}
413	echo >> ${routines}
414	# unset to be safe (quotes needed !)
415	unset "${i}"
416	done
417	echo >> ${routines}
418	fi
419
420	# postinstall and co
421	for i in preinstall postinstall preremove postremove
422	do
423	if [[ -n $(typeset -f "${i}") ]]
424	then
425	typeset -f "${i}" >> ${routines}
426	echo >> ${routines}
427	fi
428	done
429
430	# create start logic
431	echo >> ${routines}
432	echo 'case $1 in' >> ${routines}
433	echo ' preinstall) preinstall ;;' >> ${routines}
434	echo ' postinstall) postinstall ;;' >> ${routines}
435	echo ' preremove) preremove ;;' >> ${routines}
436	echo ' postremove) postremove ;;' >> ${routines}
437	echo 'esac' >> ${routines}
438	echo >> ${routines}
439	fi
440
441	unset PCATEGORIE
442	unset PNAME
443	unset PVER
444	unset PBUILD
445	unset STATE
446	unset DESCRIPTION
447	unset HOMEPAGE
448	unset PKGTYPE
449	unset PKGNAME
450	unset DEPEND
451	unset SDEPEND
452	unset PROVIDE
453	unset SPECIAL_VARS
454	unset SPECIAL_FUNCTIONS
455	unset INHERITS
456	unset SPLIT_PACKAGES
457
458	# unset these functions
459	unset -f preinstall
460	unset -f postinstall
461	unset -f preremove
462	unset -f postremove
463	}
464
465	categories2sqlite()
466	{
467	local file="$1"
468
469	if [[ ! -f ${file} ]]
470	then
471	echo "${file} does not exist, ignoring..."
472	return 0
473	fi
474
475	echo "using categories from ${file}..."
476	# create categories
477	cat ${file} \| while read pcat
478	do
479	case ${pcat} in
480	include\|profiles) continue;;
481	\#*\|"") continue ;;
482	esac
483
484	# "upsert"
485	if [[ -z $(sql "select pcat from categories where pcat='${pcat}'") ]]
486	then
487	sql "insert into categories (pcat) values('${pcat}')"
488	fi
489	done
490	}
491
492	convert_smage_db()
493	{
494	local smagefile
495
496	local PCATEGORIE
497	local PNAME
498	local PVER
499	local PBUILD
500	local STATE
501	local PKGNAME
502	local DESCRIPTION
503	local HOMEPAGE
504	local DEPEND
505	local SDEPEND
506	local PROVIDE
507	local PKGTYPE
508	local SPLIT_PACKAGES
509	local preinstall
510	local postinstall
511	local preremove
512	local postremove
513
514	# create categories - global
515	categories2sqlite "${SMAGESCRIPTSDIR}/.known_categories"
516
517	# create categories - repo specific
518	categories2sqlite "${SMAGESCRIPTSDIR}/${REPO}/.known_categories"
519
520	# create packages
521	for smagefile in $(find ${SMAGESCRIPTSDIR}/${REPO} -type f -name \*.smage2 \| sort)
522	do
523	case ${DEBUG} in
524	1\|true) echo "converting ${smagefile}" ;;
525	esac
526
527	source ${smagefile}
528
529	# build several subpackages
530	if [[ -n ${SPLIT_PACKAGES} ]]
531	then
532	split_save_variables
533	for subpackage in ${SPLIT_PACKAGES}
534	do
535	echo "Running for subpackage '${subpackage}'..."
536
537	# get the right variables for the split
538	export PNAME="${subpackage}"
539	split_info_${subpackage}
540
541	smage2sqlite
542
543	# restore smage environment
544	split_restore_variables
545	done
546	# unset all saved smage variables
547	split_unset_variables
548	else
549	smage2sqlite
550	fi
551
552	unset PCATEGORIE
553	unset PNAME
554	unset PVER
555	unset PBUILD
556	unset STATE
557	unset DESCRIPTION
558	unset HOMEPAGE
559	unset PKGTYPE
560	unset PKGNAME
561	unset DEPEND
562	unset SDEPEND
563	unset PROVIDE
564	unset SPECIAL_VARS
565	unset SPECIAL_FUNCTIONS
566	unset INHERITS
567	unset SPLIT_PACKAGES
568
569	# unset these functions
570	unset -f preinstall
571	unset -f postinstall
572	unset -f preremove
573	unset -f postremove
574	done
575	}
576
577	convert_install_db()
578	{
579	local i
580	local magefile
581	local pcat
582	local pname
583	local pver
584	local pbuild
585	local pcatid
586	local state
587	local preinstall
588	local postinstall
589	local preremove
590	local postremove
591	local pkgid
592	local dep
593	local PKGNAME
594	local STATE
595	local DESCRIPTION
596	local HOMEPAGE
597	local DEPEND
598	local SDEPEND
599	local PROVIDE
600	local PKGTYPE
601	local preinstall
602	local postinstall
603	local preremove
604	local postremove
605	local sym
606	local depname
607	local depver
608	local depbuild
609	local depcat
610	local depcatid
611	local md5file
612	local md5sum
613	local pkginfoid
614	local entrydir
615
616	# first of all add virtual categorie
617	sql "insert into categories(pcat) values('virtual')"
618
619	# create categories
620	for i in virtual ${INSTALLDB}/*
621	do
622	pcat="$(basename ${i})"
623	case ${pcat} in
624	include\|profiles) continue;;
625	esac
626
627	sql "insert into categories (pcat) values('${pcat}')"
628	done
629
630	# create packages
631	for magefile in $(find ${INSTALLDB} -type f -name *.mage\| sort)
632	do
633	case ${DEBUG} in
634	1\|true) echo "converting ${magefile}" ;;
635	esac
636
637	pcat="$(magename2pcat ${magefile})"
638	pname="$(magename2pname ${magefile})"
639	pver="$(magename2pver ${magefile})"
640	pbuild="$(magename2pbuild ${magefile})"
641
642	source ${magefile}
643
644	pcatid=$(sql "select id from categories where pcat='${pcat}'")
645	sql "insert into packages(
646	pname,
647	pver,
648	pbuild,
649	pcat_id,
650	state,
651	provide,
652	pkgtype
653	)
654	values(
655	'${pname}',
656	'${pver}',
657	'${pbuild}',
658	'${pcatid}',
659	'${STATE}',
660	'${PROVIDE}',
661	'${PKGTYPE}'
662	)"
663
664	pkgid=$(sql "select id from packages where pname='${pname}' and pver='${pver}' and pbuild='${pbuild}'")
665	# depends
666	while read sym dep
667	do
668	[[ -z ${dep} ]] && continue
669	depcat="$(dep2pcat ${dep})"
670	depcatid=$(sql "select id from categories where pcat='${depcat}'")
671	depname="$(dep2pname ${dep})"
672	depver="$(dep2pver ${dep})"
673	sql "insert into depends(pkg_id,
674	relation,
675	pcat_id,
676	pname,
677	pver,
678	pbuild)
679	values('${pkgid}',
680	'${sym}',
681	'${depcatid}',
682	'${depname}',
683	'${depver}',
684	'${depbuild}')"
685	done << EOF
686	${DEPEND}
687	EOF
688	# sdepends
689	while read sym dep
690	do
691	[[ -z ${dep} ]] && continue
692	depcat="$(dep2pcat ${dep})"
693	depcatid=$(sql "select id from categories where pcat='${depcat}'")
694	depname="$(dep2pname ${dep})"
695	depver="$(dep2pver ${dep})"
696	sql "insert into sdepends(pkg_id,
697	relation,
698	pcat_id,
699	pname,
700	pver,
701	pbuild)
702	values('${pkgid}',
703	'${sym}',
704	'${depcatid}',
705	'${depname}',
706	'${depver}',
707	'${depbuild}')"
708	done << EOF
709	${SDEPEND}
710	EOF
711
712	DESCRIPTION="$(echo ${DESCRIPTION} \| sed s:\':\'\':g)"
713	sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
714	values('${pkgid}','${ARCH}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
715
716
717	# install routines & includes
718	sql "insert into packages_routines(pkg_id,
719	mincludes,
720	postinstall,
721	preinstall,
722	preremove,
723	postremove)
724	values('${pkgid}',
725	'${mincludes}',
726	'$(typeset -f postinstall \| sed s:\':\'\':g)',
727	'$(typeset -f preinstall \| sed s:\':\'\':g)',
728	'$(typeset -f preremove \| sed s:\':\'\':g)',
729	'$(typeset -f postremove \| sed s:\':\'\':g)')"
730
731	#### ####
732	# record contents #
733	#### ####
734	pkginfoid=$(sql "select id from packages_info where pkg_id='${pkgid}' and arch='${ARCH}'")
735	entrydir="$(dirname ${magefile})"
736	sql "insert into packages_content(pkginfo_id,
737	char,
738	dirs,
739	files,
740	pipes,
741	symlinks)
742	values('${pkginfoid}',
743	'$(basename ${DBFILE} .sql).records/${pkginfoid}/char.bz2',
744	'$(basename ${DBFILE} .sql).records/${pkginfoid}/dirs.bz2',
745	'$(basename ${DBFILE} .sql).records/${pkginfoid}/files.bz2',
746	'$(basename ${DBFILE} .sql).records/${pkginfoid}/pipes.bz2',
747	'$(basename ${DBFILE} .sql).records/${pkginfoid}/symlinks.bz2')"
748	# create compressed content files
749	local entryfile
750	for entryfile in char dirs files pipes symlinks
751	do
752	install -d $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}
753	cat ${entrydir}/.${entryfile} \| bzip2 -9 >> $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}/${entryfile}.bz2
754	done
755
756	unset PKGNAME
757	unset DEPEND
758	unset SDEPEND
759	unset PROVIDE
760	unset SPECIAL_VARS
761	unset SPECIAL_FUNCTIONS
762
763	# unset these functions
764	unset -f preinstall
765	unset -f postinstall
766	unset -f preremove
767	unset -f postremove
768	done
769	}
770
771	convert_virtual_defaults()
772	{
773	local virtual
774	local package
775	local vcat
776	local vname
777	local pcat
778	local pname
779
780	sql "create table virtual_defaults(id integer primary key, vcat text,vname text, pcat text, pname text)"
781
782	while read virtual package
783	do
784	vcat="$(dirname ${virtual})"
785	vname="$(basename ${virtual})"
786	pcat="$(dirname ${package})"
787	pname="$(basename ${package})"
788
789	sql "insert into virtual_defaults(vcat,vname,pcat,pname) values('${vcat}','${vname}','${pcat}','${pname}')"
790	done < /etc/mage-profile/virtuals.defaults
791	}
792
793	METHOD="$1"
794	DBFILE="$2"
795	REPO="$3"
796
797	[[ -z ${METHOD} ]] && die "No method given. Use --install, --packages or --virtual for your appropiate task"
798	[[ -z ${DBFILE} ]] && die "No database given."
799	[[ -z ${REPO} ]] && die "No repository given."
800
801	case $1 in
802	--install\|-i)
803	create_database_layout
804	convert_install_db
805	;;
806	--packages\|-p)
807	convert_virtual_defaults
808	create_database_layout
809	convert_smage_db
810	;;
811	# --virtuals\|-v)
812	# convert_virtual_defaults
813	# ;;
814	*) die "Unkown method." ;;
815	esac