lib/mage/convert_databases_smage.sh

#!/bin/bash

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


#### fixups ####
MLIBDIR=/home/tjoke/alx-cvs/magellan-src/mage/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
}

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)"
}

convert_smage_db()
{
	local i
	local smagefile
	local PCATEGORIE
	local PNAME
	local PVER
	local PBUILD
	local pcatid
	local STATE
	local pkgid
	local dep
	local PKGNAME
	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

	# create categories
	cat ${SMAGESCRIPTSDIR}/.known_categories | while read pcat
	do
		case ${pcat} in
			include|profiles) continue;;
		esac

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

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

		source ${smagefile}

		# substitute r from pbuild
		PBUILD="${PBUILD/r/}"

		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
			[[ -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

		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 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

	# 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})"
		# substitute r from pbuild
		pbuild="${pbuild/r/}"

		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"

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

case $1 in
	--install|-i)
		create_database_layout
		convert_install_db
		;;
	--packages|-p)
		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/alx-cvs/magellan-src/mage/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	create_database_layout()
33	{
34	sql "create table categories(id integer primary key, pcat text unique)"
35	sql "create table packages(id integer primary key,
36	pname text,
37	pver text,
38	pbuild text,
39	pcat_id numeric,
40	state text,
41	provide text,
42	pkgtype text
43	)"
44	sql "create table depends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
45	sql "create table sdepends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
46	sql "create table packages_info(id integer primary key, pkg_id numeric, arch text, md5 text, mtime numeric, homepage text, description text, size numeric)"
47	#sql "create table packages_content(id integer primary key, pkginfo_id numeric, char text, dirs text, files text, pipes text, symlinks text)"
48	sql "create table packages_content(id integer primary key, pkginfo_id numeric, char blob, dirs blob, files blob, pipes blob, symlinks blob)"
49	# sql "create table packages_routines(id integer primary key,
50	# pkg_id numeric,
51	# mincludes text,
52	# preinstall text,
53	# postinstall text,
54	# preremove text,
55	# postremove text,
56	# extra_functions text,
57	# extra_vars text)"
58	sql "create table packages_routines(id integer primary key,
59	pkg_id numeric,
60	mincludes text,
61	preinstall numeric,
62	postinstall numeric,
63	preremove numeric,
64	postremove numeric,
65	script text)"
66	}
67
68	convert_smage_db()
69	{
70	local i
71	local smagefile
72	local PCATEGORIE
73	local PNAME
74	local PVER
75	local PBUILD
76	local pcatid
77	local STATE
78	local pkgid
79	local dep
80	local PKGNAME
81	local DESCRIPTION
82	local HOMEPAGE
83	local DEPEND
84	local SDEPEND
85	local PROVIDE
86	local PKGTYPE
87	local preinstall
88	local postinstall
89	local preremove
90	local postremove
91	local sym
92	local depname
93	local depver
94	local depbuild
95	local depcat
96	local depcatid
97	local md5file
98	local md5sum
99
100	# create categories
101	cat ${SMAGESCRIPTSDIR}/.known_categories \| while read pcat
102	do
103	case ${pcat} in
104	include\|profiles) continue;;
105	esac
106
107	sql "insert into categories (pcat) values('${pcat}')"
108	done
109
110	# create packages
111	for smagefile in $(find ${SMAGESCRIPTSDIR}/glibc-nptl -type f -name '*'.smage2 \| sort)
112	do
113	case ${DEBUG} in
114	1\|true) echo "converting ${smagefile}" ;;
115	esac
116
117	source ${smagefile}
118
119	# substitute r from pbuild
120	PBUILD="${PBUILD/r/}"
121
122	pcatid=$(sql "select id from categories where pcat='${PCATEGORIE}'")
123	sql "insert into packages(
124	pname,
125	pver,
126	pbuild,
127	pcat_id,
128	state,
129	provide,
130	pkgtype
131	)
132	values(
133	'${PNAME}',
134	'${PVER}',
135	'${PBUILD}',
136	'${pcatid}',
137	'${STATE}',
138	'${PROVIDE}',
139	'${PKGTYPE}'
140	)"
141
142	pkgid=$(sql "select id from packages where pname='${PNAME}' and pver='${PVER}' and pbuild='${PBUILD}'")
143	# depends
144	while read sym dep
145	do
146	[[ -z ${dep} ]] && continue
147	depcat="$(dep2pcat ${dep})"
148	depcatid=$(sql "select id from categories where pcat='${depcat}'")
149	depname="$(dep2pname ${dep})"
150	depver="$(dep2pver ${dep})"
151	sql "insert into depends(pkg_id,
152	relation,
153	pcat_id,
154	pname,
155	pver,
156	pbuild)
157	values('${pkgid}',
158	'${sym}',
159	'${depcatid}',
160	'${depname}',
161	'${depver}',
162	'${depbuild}')"
163	done << EOF
164	${DEPEND}
165	EOF
166	# sdepends
167	while read sym dep
168	do
169	[[ -z ${dep} ]] && continue
170	depcat="$(dep2pcat ${dep})"
171	depcatid=$(sql "select id from categories where pcat='${depcat}'")
172	depname="$(dep2pname ${dep})"
173	depver="$(dep2pver ${dep})"
174	sql "insert into sdepends(pkg_id,
175	relation,
176	pcat_id,
177	pname,
178	pver,
179	pbuild)
180	values('${pkgid}',
181	'${sym}',
182	'${depcatid}',
183	'${depname}',
184	'${depver}',
185	'${depbuild}')"
186	done << EOF
187	${SDEPEND}
188	EOF
189
190	for arch in i686 x86_64
191	do
192	md5file="${MAGEDIR}/${PCATEGORIE}/${PNAME}/md5/${PNAME}-${PVER}-${arch}-r${PBUILD}.md5"
193	[[ -f ${md5file} ]] && md5sum="$(cat ${md5file} \| cut -d' ' -f1)"
194
195	# fix descriptions
196	DESCRIPTION="$(echo ${DESCRIPTION} \| sed s:\':\'\':g)"
197
198	sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
199	values('${pkgid}','${arch}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
200	done
201
202	# using $INHERITS directly
203	#mincludes="$(grep -r 'minclude ' ${magefile} \| cut -d: -f2 \| sed s:minclude\ ::)"
204
205	# # #
206	# # # install routines & includes
207	# # #
208	# # # needs special magic: the last line of typeset has no ';'
209	# # # but to eval the function we must append it
210	# # # so this sed deletes the last line of the typeset output
211	# # # and replaces it with an ;} and a newline between
212	# # #
213	# # # but we will not add this fun when no postinstall etc are given
214	# # # -> [[ -n $(typeset -f postinstall ]] &&
215	# # #
216	# # # also the character ' is a problem while importing to sql
217	# # # because we use ' as escape char. so we replace it with ''
218	# # #
219	# # # $([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall \| sed s:\':\'\':g \| sed '$d');\n}")
220	# # #
221	# # sql "insert into packages_routines(pkg_id,
222	# # mincludes,
223	# # postinstall,
224	# # preinstall,
225	# # preremove,
226	# # postremove)
227	# # values('${pkgid}',
228	# # '${mincludes}',
229	# # '$([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall \| sed s:\':\'\':g \| sed '$d');\n}")',
230	# # '$([[ -n $(typeset -f preinstall) ]] && echo -e "$(typeset -f preinstall \| sed s:\':\'\':g \| sed '$d');\n}")',
231	# # '$([[ -n $(typeset -f preremove) ]] && echo -e "$(typeset -f preremove \| sed s:\':\'\':g \| sed '$d');\n}")',
232	# # '$([[ -n $(typeset -f postremove) ]] && echo -e "$(typeset -f postremove \| sed s:\':\'\':g \| sed '$d');\n}")')"
233
234	local do_preinst=0
235	local do_postinst=0
236	local do_prerm=0
237	local do_postrm=0
238	local do_script=0
239	local script=""
240
241	[[ -n $(typeset -f preinstall) ]] && do_preinst=1 && do_script=1
242	[[ -n $(typeset -f postinstall) ]] && do_postinst=1 && do_script=1
243	[[ -n $(typeset -f preremove) ]] && do_prerm=1 && do_script=1
244	[[ -n $(typeset -f postremove) ]] && do_postrm=1 && do_script=1
245
246	[[ ${do_script} = 1 ]] && script="$(basename ${DBFILE} .sql).routines/${pkgid}/routines.sh"
247
248	sql "insert into packages_routines(pkg_id,
249	mincludes,
250	postinstall,
251	preinstall,
252	preremove,
253	postremove,
254	script)
255	values('${pkgid}',
256	'${INHERITS}',
257	'${do_postinst}',
258	'${do_pretinst}',
259	'${do_prerm}',
260	'${do_postrm}',
261	'${script}')"
262
263	# create it only if do_script=1
264	if [[ ${do_script} = 1 ]]
265	then
266	# create a routines script
267	local routines=$(dirname ${DBFILE})/${script}
268	install -d $(dirname ${routines})
269
270	echo "#!/bin/sh" > ${routines}
271	echo "# routines.sh script for #${pkgid}, ${PNAME}-${PVER}-${PBUILD}" >> ${routines}
272	echo >> ${routines}
273
274
275	# special functions and variables
276	if [[ -n ${SPECIAL_VARS} ]]
277	then
278	local i
279	for i in ${SPECIAL_VARS}
280	do
281	# being tricky here :)
282	echo "${i}=\"$(eval echo \$${i})\"" >> ${routines}
283	done
284	echo >> ${routines}
285	fi
286
287	# add special functions
288	if [[ -n ${SPECIAL_FUNCTIONS} ]]
289	then
290	local i
291	for i in ${SPECIAL_FUNCTIONS}
292	do
293	# add to mage (quotes needed !)
294	typeset -f "${i}" >> ${routines}
295	echo >> ${routines}
296	# unset to be safe (quotes needed !)
297	unset "${i}"
298	done
299	echo >> ${routines}
300	fi
301
302	# postinstall and co
303	for i in preinstall postinstall preremove postremove
304	do
305	if [[ -n $(typeset -f "${i}") ]]
306	then
307	typeset -f "${i}" >> ${routines}
308	echo >> ${routines}
309	fi
310	done
311
312	# create start logic
313	echo >> ${routines}
314	echo 'case $1 in' >> ${routines}
315	echo ' preinstall) preinstall ;;' >> ${routines}
316	echo ' postinstall) postinstall ;;' >> ${routines}
317	echo ' preremove) preremove ;;' >> ${routines}
318	echo ' postremove) postremove ;;' >> ${routines}
319	echo 'esac' >> ${routines}
320	echo >> ${routines}
321	fi
322
323
324	unset PCATEGORIE
325	unset PNAME
326	unset PVER
327	unset PBUILD
328	unset STATE
329	unset DESCRIPTION
330	unset HOMEPAGE
331	unset PKGTYPE
332	unset PKGNAME
333	unset DEPEND
334	unset SDEPEND
335	unset PROVIDE
336	unset SPECIAL_VARS
337	unset SPECIAL_FUNCTIONS
338	unset INHERITS
339
340	# unset these functions
341	unset -f preinstall
342	unset -f postinstall
343	unset -f preremove
344	unset -f postremove
345	done
346	}
347
348	convert_install_db()
349	{
350	local i
351	local magefile
352	local pcat
353	local pname
354	local pver
355	local pbuild
356	local pcatid
357	local state
358	local preinstall
359	local postinstall
360	local preremove
361	local postremove
362	local pkgid
363	local dep
364	local PKGNAME
365	local STATE
366	local DESCRIPTION
367	local HOMEPAGE
368	local DEPEND
369	local SDEPEND
370	local PROVIDE
371	local PKGTYPE
372	local preinstall
373	local postinstall
374	local preremove
375	local postremove
376	local sym
377	local depname
378	local depver
379	local depbuild
380	local depcat
381	local depcatid
382	local md5file
383	local md5sum
384	local pkginfoid
385	local entrydir
386
387	# create categories
388	for i in virtual ${INSTALLDB}/*
389	do
390	pcat="$(basename ${i})"
391	case ${pcat} in
392	include\|profiles) continue;;
393	esac
394
395	sql "insert into categories (pcat) values('${pcat}')"
396	done
397
398	# create packages
399	for magefile in $(find ${INSTALLDB} -type f -name *.mage\| sort)
400	do
401	case ${DEBUG} in
402	1\|true) echo "converting ${magefile}" ;;
403	esac
404
405	pcat="$(magename2pcat ${magefile})"
406	pname="$(magename2pname ${magefile})"
407	pver="$(magename2pver ${magefile})"
408	pbuild="$(magename2pbuild ${magefile})"
409	# substitute r from pbuild
410	pbuild="${pbuild/r/}"
411
412	source ${magefile}
413
414	pcatid=$(sql "select id from categories where pcat='${pcat}'")
415	sql "insert into packages(
416	pname,
417	pver,
418	pbuild,
419	pcat_id,
420	state,
421	provide,
422	pkgtype
423	)
424	values(
425	'${pname}',
426	'${pver}',
427	'${pbuild}',
428	'${pcatid}',
429	'${STATE}',
430	'${PROVIDE}',
431	'${PKGTYPE}'
432	)"
433
434	pkgid=$(sql "select id from packages where pname='${pname}' and pver='${pver}' and pbuild='${pbuild}'")
435	# depends
436	while read sym dep
437	do
438	[[ -z ${dep} ]] && continue
439	depcat="$(dep2pcat ${dep})"
440	depcatid=$(sql "select id from categories where pcat='${depcat}'")
441	depname="$(dep2pname ${dep})"
442	depver="$(dep2pver ${dep})"
443	sql "insert into depends(pkg_id,
444	relation,
445	pcat_id,
446	pname,
447	pver,
448	pbuild)
449	values('${pkgid}',
450	'${sym}',
451	'${depcatid}',
452	'${depname}',
453	'${depver}',
454	'${depbuild}')"
455	done << EOF
456	${DEPEND}
457	EOF
458	# sdepends
459	while read sym dep
460	do
461	[[ -z ${dep} ]] && continue
462	depcat="$(dep2pcat ${dep})"
463	depcatid=$(sql "select id from categories where pcat='${depcat}'")
464	depname="$(dep2pname ${dep})"
465	depver="$(dep2pver ${dep})"
466	sql "insert into sdepends(pkg_id,
467	relation,
468	pcat_id,
469	pname,
470	pver,
471	pbuild)
472	values('${pkgid}',
473	'${sym}',
474	'${depcatid}',
475	'${depname}',
476	'${depver}',
477	'${depbuild}')"
478	done << EOF
479	${SDEPEND}
480	EOF
481
482	DESCRIPTION="$(echo ${DESCRIPTION} \| sed s:\':\'\':g)"
483	sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
484	values('${pkgid}','${ARCH}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"
485
486
487	# install routines & includes
488	sql "insert into packages_routines(pkg_id,
489	mincludes,
490	postinstall,
491	preinstall,
492	preremove,
493	postremove)
494	values('${pkgid}',
495	'${mincludes}',
496	'$(typeset -f postinstall \| sed s:\':\'\':g)',
497	'$(typeset -f preinstall \| sed s:\':\'\':g)',
498	'$(typeset -f preremove \| sed s:\':\'\':g)',
499	'$(typeset -f postremove \| sed s:\':\'\':g)')"
500
501	#### ####
502	# record contents #
503	#### ####
504	pkginfoid=$(sql "select id from packages_info where pkg_id='${pkgid}' and arch='${ARCH}'")
505	entrydir="$(dirname ${magefile})"
506	sql "insert into packages_content(pkginfo_id,
507	char,
508	dirs,
509	files,
510	pipes,
511	symlinks)
512	values('${pkginfoid}',
513	'$(basename ${DBFILE} .sql).records/${pkginfoid}/char.bz2',
514	'$(basename ${DBFILE} .sql).records/${pkginfoid}/dirs.bz2',
515	'$(basename ${DBFILE} .sql).records/${pkginfoid}/files.bz2',
516	'$(basename ${DBFILE} .sql).records/${pkginfoid}/pipes.bz2',
517	'$(basename ${DBFILE} .sql).records/${pkginfoid}/symlinks.bz2')"
518	# create compressed content files
519	local entryfile
520	for entryfile in char dirs files pipes symlinks
521	do
522	install -d $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}
523	cat ${entrydir}/.${entryfile} \| bzip2 -9 >> $(dirname ${DBFILE})/$(basename ${DBFILE} .sql).records/${pkginfoid}/${entryfile}.bz2
524	done
525
526	unset PKGNAME
527	unset DEPEND
528	unset SDEPEND
529	unset PROVIDE
530	unset SPECIAL_VARS
531	unset SPECIAL_FUNCTIONS
532
533	# unset these functions
534	unset -f preinstall
535	unset -f postinstall
536	unset -f preremove
537	unset -f postremove
538	done
539	}
540
541	convert_virtual_defaults()
542	{
543	local virtual
544	local package
545	local vcat
546	local vname
547	local pcat
548	local pname
549
550	sql "create table virtual_defaults(id integer primary key, vcat text,vname text, pcat text, pname text)"
551
552	while read virtual package
553	do
554	vcat="$(dirname ${virtual})"
555	vname="$(basename ${virtual})"
556	pcat="$(dirname ${package})"
557	pname="$(basename ${package})"
558
559	sql "insert into virtual_defaults(vcat,vname,pcat,pname) values('${vcat}','${vname}','${pcat}','${pname}')"
560	done < /etc/mage-profile/virtuals.defaults
561	}
562
563	METHOD="$1"
564	DBFILE="$2"
565
566	[[ -z ${METHOD} ]] && die "No method given. Use --install, --packages or --virtual for your appropiate task"
567	[[ -z ${DBFILE} ]] && die "No database given."
568
569	case $1 in
570	--install\|-i)
571	create_database_layout
572	convert_install_db
573	;;
574	--packages\|-p)
575	create_database_layout
576	convert_smage_db
577	;;
578	--virtuals\|-v)
579	convert_virtual_defaults
580	;;
581	*) die "Unkown method." ;;
582	esac