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	niro	489	#!/bin/bash
2
3			source /etc/mage.rc.global
4			source /etc/mage.rc
5
6
7			#### fixups ####
8	niro	1113	MLIBDIR=/home/tjoke/svn/magellan-source/branches/mage-sql/usr/lib/mage
9	niro	489	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	niro	1113	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	niro	489	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	niro	1113	smage2sqlite()
213	niro	489	{
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	niro	1113	pcatid=$(sql "select id from categories where pcat='${PCATEGORIE}'")
228	niro	489
229	niro	1113	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	niro	489
248	niro	1113	pkgid=$(sql "select id from packages where pname='${PNAME}' and pver='${PVER}' and pbuild='${PBUILD}'")
249
250			# depends
251			while read sym dep
252	niro	489	do
253	niro	1113	# ignore scripts atm -FIXME!!!
254			case ${sym} in
255			\$\(*) continue ;;
256	niro	489	esac
257
258	niro	1113	[[ -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	niro	489
264	niro	1113	if [[ -z ${depcatid} ]]
265			then
266			die "Error: '${PNAME}' -> depcat '${depcat}' has no depcatid, it does no exist in database!"
267			fi
268	niro	489
269	niro	1113	sql "insert into depends(pkg_id,
270			relation,
271			pcat_id,
272	niro	489	pname,
273			pver,
274	niro	1113	pbuild)
275			values('${pkgid}',
276			'${sym}',
277			'${depcatid}',
278			'${depname}',
279			'${depver}',
280			'${depbuild}')"
281			done << EOF
282	niro	489	${DEPEND}
283			EOF
284	niro	1113	# 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	niro	489	${SDEPEND}
306			EOF
307
308	niro	1113	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	niro	489
313	niro	1113	# fix descriptions
314			DESCRIPTION="$(echo ${DESCRIPTION} \| sed s:\':\'\':g)"
315	niro	489
316	niro	1113	sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
317			values('${pkgid}','${arch}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
318			done
319	niro	489
320	niro	1113	# using $INHERITS directly
321			#mincludes="$(grep -r 'minclude ' ${magefile} \| cut -d: -f2 \| sed s:minclude\ ::)"
322	niro	489
323	niro	1113	# # #
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	niro	489
352	niro	1113	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	niro	489
359	niro	1113	[[ -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	niro	489
364	niro	1113	[[ ${do_script} = 1 ]] && script="$(basename ${DBFILE} .sql).routines/${pkgid}/routines.sh"
365	niro	489
366	niro	1113	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	niro	489
381			# create it only if do_script=1
382			if [[ ${do_script} = 1 ]]
383			then
384	niro	1113	# create a routines script
385			local routines=$(dirname ${DBFILE})/${script}
386			install -d $(dirname ${routines})
387	niro	489
388	niro	1113	echo '#!/bin/sh' > ${routines}
389			echo "# routines.sh script for ${pkgid}, ${PNAME}-${PVER}-${PBUILD}" >> ${routines}
390			echo >> ${routines}
391	niro	489
392
393	niro	1113	# 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	niro	489	then
425	niro	1113	typeset -f "${i}" >> ${routines}
426			echo >> ${routines}
427	niro	489	fi
428	niro	1113	done
429	niro	489
430	niro	1113	# 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	niro	489	then
487	niro	1113	sql "insert into categories (pcat) values('${pcat}')"
488	niro	489	fi
489	niro	1113	done
490			}
491	niro	489
492	niro	1113	convert_smage_db()
493			{
494			local smagefile
495	niro	489
496	niro	1113	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	niro	489
514	niro	1113	# create categories - global
515			categories2sqlite "${SMAGESCRIPTSDIR}/.known_categories"
516	niro	489
517	niro	1113	# 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	niro	489	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	niro	1113	unset SPLIT_PACKAGES
568	niro	489
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	niro	1113	# first of all add virtual categorie
617			sql "insert into categories(pcat) values('virtual')"
618
619	niro	489	# 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	niro	1113	REPO="$3"
796	niro	489
797			[[ -z ${METHOD} ]] && die "No method given. Use --install, --packages or --virtual for your appropiate task"
798			[[ -z ${DBFILE} ]] && die "No database given."
799	niro	1113	[[ -z ${REPO} ]] && die "No repository given."
800	niro	489
801			case $1 in
802			--install\|-i)
803			create_database_layout
804			convert_install_db
805			;;
806			--packages\|-p)
807	niro	1113	convert_virtual_defaults
808	niro	489	create_database_layout
809			convert_smage_db
810			;;
811	niro	1113	# --virtuals\|-v)
812			# convert_virtual_defaults
813			# ;;
814	niro	489	*) die "Unkown method." ;;
815			esac