rootfs_rpm/package_rpm.bbclass: Move func from rootfs_rpm to package_rpm

package_deb.bbclass:
1. Modified package_update_index_rpm() and package_generate_rpm_conf()
to generate sperate depsolver db and rpm configuration, for target
packages and host packages respectively.

2. Added new function package_install_internal_rpm() to install a list
deb packages to a specified root directory, with the specified package
architecutre information.

3. Added new function resolve_package_rpm() to resolve package names to
filepaths.

rootfs_deb.bbclass:
Used the above new functions to install the rootfs.

[sgw: merged changes for createrepo]
Signed-off-by: Lianhao Lu <lianhao.lu@intel.com>
Signed-off-by: Saul Wold <sgw@linux.intel.com>

diff --git a/meta/classes/package_rpm.bbclass b/meta/classes/package_rpm.bbclass
index 8891f06ffa96e335af949c763e2c1dfc4e9bf8c6..cc262dc8316272002ac749d931895fc12d9e853e 100644 (file)
--- a/meta/classes/package_rpm.bbclass
+++ b/meta/classes/package_rpm.bbclass
@@ -15,6 +15,8 @@ python package_rpm_install () {
        bb.fatal("package_rpm_install not implemented!")
 }
 
+RPMCONF_TARGET_BASE = "${DEPLOY_DIR_RPM}/solvedb"
+RPMCONF_HOST_BASE = "${DEPLOY_DIR_RPM}/solvedb-sdk"
 #
 # Update the Packages depsolver db in ${DEPLOY_DIR_RPM}
 #
@@ -26,15 +28,18 @@ package_update_index_rpm () {
        fi
 
        packagedirs=""
+       packagedirs_sdk=""
        for arch in $rpmarchs ; do
                sdkarch=`echo $arch | sed -e 's/${HOST_ARCH}/${SDK_ARCH}/'`
+               extension="-nativesdk"
+               if [ "$sdkarch" = "all" -o "$sdkarch" = "any" -o "$sdkarch" = "noarch" ]; then
+                   extension=""
+               fi
                packagedirs="$packagedirs ${DEPLOY_DIR_RPM}/$arch"
-               #packagedirs="$packagedirs ${DEPLOY_DIR_RPM}/$sdkarch-nativesdk"
+               packagedirs_sdk="$packagedirs_sdk ${DEPLOY_DIR_RPM}/$sdkarch$extension"
        done
 
-       #packagedirs="$packagedirs ${DEPLOY_DIR_RPM}/${SDK_ARCH}-${TARGET_ARCH}-canadian"
-
-       cat /dev/null > ${DEPLOY_DIR_RPM}/solvedb.conf
+       cat /dev/null > ${RPMCONF_TARGET_BASE}.conf
        for pkgdir in $packagedirs; do
                if [ -e $pkgdir/ ]; then
                        echo "Generating solve db for $pkgdir..."
@@ -48,7 +53,25 @@ package_update_index_rpm () {
                                --ignoresize --nosignature --nodigest \
                                -D "__dbi_txn create nofsync" \
                                $pkgdir/solvedb/manifest
-                       echo $pkgdir/solvedb >> ${DEPLOY_DIR_RPM}/solvedb.conf
+                       echo $pkgdir/solvedb >> ${RPMCONF_TARGET_BASE}.conf
+               fi
+       done
+
+       cat /dev/null > ${RPMCONF_HOST_BASE}.conf
+       for pkgdir in $packagedirs_sdk; do
+               if [ -e $pkgdir/ ]; then
+                       echo "Generating solve db for $pkgdir..."
+                       rm -rf $pkgdir/solvedb
+                       mkdir -p $pkgdir/solvedb
+                       echo "# Dynamically generated solve manifest" >> $pkgdir/solvedb/manifest
+                       find $pkgdir -maxdepth 1 -type f >> $pkgdir/solvedb/manifest
+                       ${RPM} -i --replacepkgs --replacefiles --oldpackage \
+                               -D "_dbpath $pkgdir/solvedb" --justdb \
+                               --noaid --nodeps --noorder --noscripts --notriggers --noparentdirs --nolinktos --stats \
+                               --ignoresize --nosignature --nodigest \
+                               -D "__dbi_txn create nofsync" \
+                               $pkgdir/solvedb/manifest
+                       echo $pkgdir/solvedb >> ${RPMCONF_HOST_BASE}.conf
                fi
        done
 }
@@ -58,16 +81,27 @@ package_update_index_rpm () {
 # generated depsolver db's...
 #
 package_generate_rpm_conf () {
-       printf "_solve_dbpath " > ${DEPLOY_DIR_RPM}/solvedb.macro
+       printf "_solve_dbpath " > ${RPMCONF_TARGET_BASE}.macro
+       colon=false
+       for each in `cat ${RPMCONF_TARGET_BASE}.conf` ; do
+               if [ "$colon" == true ]; then
+                       printf ":" >> ${RPMCONF_TARGET_BASE}.macro
+               fi
+               printf "%s" $each >> ${RPMCONF_TARGET_BASE}.macro
+               colon=true
+       done
+       printf "\n" >> ${RPMCONF_TARGET_BASE}.macro
+
+       printf "_solve_dbpath " > ${RPMCONF_HOST_BASE}.macro
        colon=false
-       for each in `cat ${DEPLOY_DIR_RPM}/solvedb.conf` ; do
+       for each in `cat ${RPMCONF_HOST_BASE}.conf` ; do
                if [ "$colon" == true ]; then
-                       printf ":" >> ${DEPLOY_DIR_RPM}/solvedb.macro
+                       printf ":" >> ${RPMCONF_HOST_BASE}.macro
                fi
-               printf "%s" $each >> ${DEPLOY_DIR_RPM}/solvedb.macro
+               printf "%s" $each >> ${RPMCONF_HOST_BASE}.macro
                colon=true
        done
-       printf "\n" >> ${DEPLOY_DIR_RPM}/solvedb.macro
+       printf "\n" >> ${RPMCONF_HOST_BASE}.macro
 }
 
 rpm_log_check() {
@@ -90,6 +124,182 @@ rpm_log_check() {
        true
 }
 
+
+#
+# Resolve package names to filepaths
+# resolve_pacakge <pkgname> <solvdb conffile>
+#
+resolve_package_rpm () {
+       local pkg="$1"
+       local conffile="$2"
+       local pkg_name=""
+       for solve in `cat ${conffile}`; do
+               pkg_name=$(${RPM} -D "_dbpath $solve" -D "__dbi_txn create nofsync" -q --yaml $pkg | grep -i 'Packageorigin' | cut -d : -f 2)
+               if [ -n "$pkg_name" ]; then
+                       break;
+               fi
+       done
+       echo $pkg_name
+}
+
+#
+# install a bunch of packages using rpm
+# the following shell variables needs to be set before calling this func:
+# INSTALL_ROOTFS_RPM - install root dir
+# INSTALL_PLATFORM_RPM - main platform
+# INSTALL_PLATFORM_EXTRA_RPM - extra platform
+# INSTALL_CONFBASE_RPM - configuration file base name
+# INSTALL_PACKAGES_NORMAL_RPM - packages to be installed
+# INSTALL_PACKAGES_ATTEMPTONLY_RPM - packages attemped to be installed only
+# INSTALL_PACKAGES_LINGUAS_RPM - additional packages for uclibc
+# INSTALL_PROVIDENAME_RPM - content for provide name
+# INSTALL_TASK_RPM - task name
+
+package_install_internal_rpm () {
+
+       local target_rootfs="${INSTALL_ROOTFS_RPM}"
+       local platform="${INSTALL_PLATFORM_RPM}"
+       local platform_extra="${INSTALL_PLATFORM_EXTRA_RPM}"
+       local confbase="${INSTALL_CONFBASE_RPM}"
+       local package_to_install="${INSTALL_PACKAGES_NORMAL_RPM}"
+       local package_attemptonly="${INSTALL_PACKAGES_ATTEMPTONLY_RPM}"
+       local package_lingusa="${INSTALL_PACKAGES_LINGUAS_RPM}"
+       local providename="${INSTALL_PROVIDENAME_RPM}"
+       local task="${INSTALL_TASK_RPM}"
+
+       # Setup base system configuration
+       mkdir -p ${target_rootfs}/etc/rpm/
+       echo "${platform}-unknown-linux" >${target_rootfs}/etc/rpm/platform
+       if [ ! -z "$platform_extra" ]; then
+               for pt in $platform_extra ; do
+                       echo "$pt-unknown-linux" >> ${target_rootfs}/etc/rpm/platform
+               done
+       fi
+
+       # Tell RPM that the "/" directory exist and is available
+       mkdir -p ${target_rootfs}/etc/rpm/sysinfo
+       echo "/" >${target_rootfs}/etc/rpm/sysinfo/Dirnames
+       if [ ! -z "$providename" ]; then
+               >>${target_rootfs}/etc/rpm/sysinfo/Providename
+               for provide in $providename ; do
+                       echo $provide >> ${target_rootfs}/etc/rpm/sysinfo/Providename
+               done
+       fi
+
+       # Setup manifest of packages to install...
+       mkdir -p ${target_rootfs}/install
+       echo "# Install manifest" > ${target_rootfs}/install/install.manifest
+
+       # Uclibc builds don't provide this stuff...
+       if [ x${TARGET_OS} = "xlinux" ] || [ x${TARGET_OS} = "xlinux-gnueabi" ] ; then
+               if [ ! -z "${package_lingusa}" ]; then
+                       for pkg in ${package_lingusa}; do
+                               echo "Processing $pkg..."
+                               pkg_name=$(resolve_package_rpm $pkg ${confbase}.conf)
+                               if [ -z "$pkg_name" ]; then
+                                       echo "Unable to find package $pkg!"
+                                       exit 1
+                               fi
+                               echo $pkg_name >> ${IMAGE_ROOTFS}/install/install.manifest
+                       done
+               fi
+       fi
+
+       if [ ! -z "${package_to_install}" ]; then
+               for pkg in ${package_to_install} ; do
+                       echo "Processing $pkg..."
+                       pkg_name=$(resolve_package_rpm $pkg ${confbase}.conf)
+                       if [ -z "$pkg_name" ]; then
+                               echo "Unable to find package $pkg!"
+                               exit 1
+                       fi
+                       echo $pkg_name >> ${target_rootfs}/install/install.manifest
+               done
+       fi
+
+       # Generate an install solution by doing a --justdb install, then recreate it with
+       # an actual package install!
+       ${RPM} -D "_rpmds_sysinfo_path ${target_rootfs}/etc/rpm/sysinfo" \
+               -D "_dbpath ${target_rootfs}/install" -D "`cat ${confbase}.macro`" \
+               -D "__dbi_txn create nofsync" \
+               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
+               ${target_rootfs}/install/install.manifest
+
+       if [ ! -z "${package_attemptonly}" ]; then
+               echo "Adding attempt only packages..."
+               for pkg in ${package_attemptonly} ; do
+                       echo "Processing $pkg..."
+                       pkg_name=$(resolve_package_rpm $pkg ${confbase}.conf)
+                       if [ -z "$pkg_name" ]; then
+                               echo "Unable to find package $pkg!"
+                               exit 1
+                       fi
+                       echo "Attempting $pkg_name..." >> "${WORKDIR}/temp/log.do_${task}_attemptonly.${PID}"
+                       ${RPM} -D "_rpmds_sysinfo_path ${target_rootfs}/etc/rpm/sysinfo" \
+                               -D "_dbpath ${target_rootfs}/install" -D "`cat ${confbase}.macro`" \
+                               -D "__dbi_txn create nofsync private" \
+                               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
+                       $pkg_name >> "${WORKDIR}/temp/log.do_${task}_attemptonly.${PID}" || true
+               done
+       fi
+
+       #### Note: 'Recommends' is an arbitrary tag that means _SUGGESTS_ in Poky..
+       # Add any recommended packages to the image
+       # RPM does not solve for recommended packages because they are optional...
+       # So we query them and tree them like the ATTEMPTONLY packages above...
+       # Change the loop to "1" to run this code...
+       loop=0
+       if [ $loop -eq 1 ]; then
+        echo "Processing recommended packages..."
+        cat /dev/null >  ${target_rootfs}/install/recommend.list
+        while [ $loop -eq 1 ]; do
+               # Dump the full set of recommends...
+               ${RPM} -D "_rpmds_sysinfo_path ${target_rootfs}/etc/rpm/sysinfo" \
+                       -D "_dbpath ${IMAGE_ROOTFS}/install" -D "`cat ${confbase}.macro`" \
+                       -D "__dbi_txn create nofsync private" \
+                       -qa --qf "[%{RECOMMENDS}\n]" | sort -u > ${target_rootfs}/install/recommend
+               # Did we add more to the list?
+               grep -v -x -F -f ${target_rootfs}/install/recommend.list ${target_rootfs}/install/recommend > ${target_rootfs}/install/recommend.new || true
+               # We don't want to loop unless there is a change to the list!
+               loop=0
+               cat ${target_rootfs}/install/recommend.new | \
+                while read pkg ; do
+                       # Ohh there was a new one, we'll need to loop again...
+                       loop=1
+                       echo "Processing $pkg..."
+                       pkg_name=$(resolve_package $pkg ${confbase}.conf)
+                       if [ -z "$pkg_name" ]; then
+                               echo "Unable to find package $pkg." >> "${WORKDIR}/temp/log.do_${task}_recommend.${PID}"
+                               continue
+                       fi
+                       echo "Attempting $pkg_name..." >> "${WORKDIR}/temp/log.do_{task}_recommend.${PID}"
+                       ${RPM} -D "_rpmds_sysinfo_path ${target_rootfs}/etc/rpm/sysinfo" \
+                               -D "_dbpath ${target_rootfs}/install" -D "`cat ${confbase}.macro`" \
+                               -D "__dbi_txn create nofsync private" \
+                               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
+                               $pkg_name >> "${WORKDIR}/temp/log.do_${task}_recommend.${PID}" 2>&1 || true
+               done
+               cat ${target_rootfs}/install/recommend.list ${target_rootfs}/install/recommend.new | sort -u > ${target_rootfs}/install/recommend.new.list
+               mv -f ${target_rootfs}/install/recommend.new.list ${target_rootfs}/install/recommend.list
+               rm ${target_rootfs}/install/recommend ${target_rootfs}/install/recommend.new
+        done
+       fi
+
+       # Now that we have a solution, pull out a list of what to install...
+       echo "Manifest: ${target_rootfs}/install/install.manifest"
+       ${RPM} -D "_dbpath ${target_rootfs}/install" -qa --yaml \
+               -D "__dbi_txn create nofsync private" \
+               | grep -i 'Packageorigin' | cut -d : -f 2 > ${target_rootfs}/install/install_solution.manifest
+
+       # Attempt install
+       ${RPM} --root ${target_rootfs} \
+               -D "_rpmds_sysinfo_path ${target_rootfs}/etc/rpm/sysinfo" \
+               -D "_dbpath ${rpmlibdir}" \
+               --noscripts --notriggers --noparentdirs --nolinktos \
+               -D "__dbi_txn create nofsync private" \
+               -Uhv ${target_rootfs}/install/install_solution.manifest
+}
+
 python write_specfile () {
        import textwrap
 

diff --git a/meta/classes/rootfs_rpm.bbclass b/meta/classes/rootfs_rpm.bbclass
index 26aaa1f8c3a57d3b1ae2da21a0807843e78cb20b..d9a9c7d8a8b95f59d59a7f6574efe67ed0a1f310 100644 (file)
--- a/meta/classes/rootfs_rpm.bbclass
+++ b/meta/classes/rootfs_rpm.bbclass
@@ -37,7 +37,7 @@ RPM="rpm ${RPMOPTS}"
 do_rootfs[lockfiles] += "${DEPLOY_DIR_RPM}/rpm.lock"
 
 fakeroot rootfs_rpm_do_rootfs () {
-       set +x
+       #set +x
 
        ${RPM_PREPROCESS_COMMANDS}
 
@@ -46,123 +46,18 @@ fakeroot rootfs_rpm_do_rootfs () {
        # Setup base system configuration
        mkdir -p ${IMAGE_ROOTFS}/etc/rpm/
 
-       # Default arch is the top..
-       echo "${TARGET_ARCH}-unknown-linux" >${IMAGE_ROOTFS}/etc/rpm/platform
-       # Add the rest in sort order..
-       for each in ${PACKAGE_ARCHS} ; do
-               echo "$each""-unknown-linux" >>${IMAGE_ROOTFS}/etc/rpm/platform
-       done
-
-       # Tell RPM that the "/" directory exist and is available
-       mkdir -p ${IMAGE_ROOTFS}/etc/rpm/sysinfo
-       echo "/" >${IMAGE_ROOTFS}/etc/rpm/sysinfo/Dirnames
-
-       # Setup manifest of packages to install...
-       mkdir -p ${IMAGE_ROOTFS}/install
-       echo "# Install manifest" > ${IMAGE_ROOTFS}/install/install.manifest
-
-       # Uclibc builds don't provide this stuff...
-       if [ x${TARGET_OS} = "xlinux" ] || [ x${TARGET_OS} = "xlinux-gnueabi" ] ; then 
-               if [ ! -z "${LINGUAS_INSTALL}" ]; then
-                       for pkg in ${LINGUAS_INSTALL}; do
-                               echo "Processing $pkg..."
-                               pkg_name=$(resolve_package $pkg)
-                               if [ -z "$pkg_name" ]; then
-                                       echo "Unable to find package $pkg!"
-                                       exit 1
-                               fi
-                               echo $pkg_name >> ${IMAGE_ROOTFS}/install/install.manifest
-                       done
-               fi
-       fi
+       #install pacakges
+       export INSTALL_ROOTFS_RPM="${IMAGE_ROOTFS}"
+       export INSTALL_PLATFORM_RPM="${TARGET_ARCH}"
+       export INSTALL_PLATFORM_EXTRA_RPM="${PACKAGE_ARCHS}"
+       export INSTALL_CONFBASE_RPM="${RPMCONF_TARGET_BASE}"
+       export INSTALL_PACKAGES_NORMAL_RPM="${PACKAGE_INSTALL}"
+       export INSTALL_PACKAGES_ATTEMPTONLY_RPM="${PACKAGE_INSTALL_ATTEMPTONLY}"
+       export INSTALL_PACKAGES_LINGUAS_RPM="${LINGUAS_INSTALL}"
+       export INSTALL_PROVIDENAME_RPM=""
+       export INSTALL_TASK_RPM="populate_sdk"
 
-       if [ ! -z "${PACKAGE_INSTALL}" ]; then
-               for pkg in ${PACKAGE_INSTALL} ; do
-                       echo "Processing $pkg..."
-                       pkg_name=$(resolve_package $pkg)
-                       if [ -z "$pkg_name" ]; then
-                               echo "Unable to find package $pkg!"
-                               exit 1
-                       fi
-                       echo $pkg_name >> ${IMAGE_ROOTFS}/install/install.manifest
-               done
-       fi
-
-       # Generate an install solution by doing a --justdb install, then recreate it with
-       # an actual package install!
-       ${RPM} -D "_dbpath ${IMAGE_ROOTFS}/install" -D "`cat ${DEPLOY_DIR_RPM}/solvedb.macro`" \
-               -D "__dbi_txn create nofsync" \
-               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
-               ${IMAGE_ROOTFS}/install/install.manifest
-
-       if [ ! -z "${PACKAGE_INSTALL_ATTEMPTONLY}" ]; then
-               echo "Adding attempt only packages..."
-               for pkg in ${PACKAGE_INSTALL_ATTEMPTONLY} ; do
-                       echo "Processing $pkg..."
-                       pkg_name=$(resolve_package $pkg)
-                       if [ -z "$pkg_name" ]; then
-                               echo "Unable to find package $pkg!"
-                               exit 1
-                       fi
-                       echo "Attempting $pkg_name..." >> "${WORKDIR}/temp/log.do_rootfs_attemptonly.${PID}"
-                       ${RPM} -D "_dbpath ${IMAGE_ROOTFS}/install" -D "`cat ${DEPLOY_DIR_RPM}/solvedb.macro`" \
-                               -D "__dbi_txn create nofsync private" \
-                               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
-                       $pkg_name >> "${WORKDIR}/temp/log.do_rootfs_attemptonly.${PID}" || true
-               done
-       fi
-
-#### Note: 'Recommends' is an arbitrary tag that means _SUGGESTS_ in Poky..
-       # Add any recommended packages to the image
-       # RPM does not solve for recommended packages because they are optional...
-       # So we query them and tree them like the ATTEMPTONLY packages above...
-       # Change the loop to "1" to run this code...
-       loop=0
-       if [ $loop -eq 1 ]; then
-        echo "Processing recommended packages..."
-        cat /dev/null >  ${IMAGE_ROOTFS}/install/recommend.list
-        while [ $loop -eq 1 ]; do
-               # Dump the full set of recommends...
-               ${RPM} -D "_dbpath ${IMAGE_ROOTFS}/install" -D "`cat ${DEPLOY_DIR_RPM}/solvedb.macro`" \
-                       -D "__dbi_txn create nofsync private" \
-                       -qa --qf "[%{RECOMMENDS}\n]" | sort -u > ${IMAGE_ROOTFS}/install/recommend
-               # Did we add more to the list?
-               grep -v -x -F -f ${IMAGE_ROOTFS}/install/recommend.list ${IMAGE_ROOTFS}/install/recommend > ${IMAGE_ROOTFS}/install/recommend.new || true
-               # We don't want to loop unless there is a change to the list!
-               loop=0
-               cat ${IMAGE_ROOTFS}/install/recommend.new | \
-                while read pkg ; do
-                       # Ohh there was a new one, we'll need to loop again...
-                       loop=1
-                       echo "Processing $pkg..."
-                       pkg_name=$(resolve_package $pkg)
-                       if [ -z "$pkg_name" ]; then
-                               echo "Unable to find package $pkg." >> "${WORKDIR}/temp/log.do_rootfs_recommend.${PID}"
-                               continue
-                       fi
-                       echo "Attempting $pkg_name..." >> "${WORKDIR}/temp/log.do_rootfs_recommend.${PID}"
-                       ${RPM} -D "_dbpath ${IMAGE_ROOTFS}/install" -D "`cat ${DEPLOY_DIR_RPM}/solvedb.macro`" \
-                               -D "__dbi_txn create nofsync private" \
-                               -U --justdb --noscripts --notriggers --noparentdirs --nolinktos --ignoresize \
-                               $pkg_name >> "${WORKDIR}/temp/log.do_rootfs_recommend.${PID}" 2>&1 || true
-               done
-               cat ${IMAGE_ROOTFS}/install/recommend.list ${IMAGE_ROOTFS}/install/recommend.new | sort -u > ${IMAGE_ROOTFS}/install/recommend.new.list
-               mv ${IMAGE_ROOTFS}/install/recommend.new.list ${IMAGE_ROOTFS}/install/recommend.list
-               rm ${IMAGE_ROOTFS}/install/recommend ${IMAGE_ROOTFS}/install/recommend.new
-        done
-       fi
-
-       # Now that we have a solution, pull out a list of what to install...
-       echo "Manifest: ${IMAGE_ROOTFS}/install/install.manifest"
-       ${RPM} -D "_dbpath ${IMAGE_ROOTFS}/install" -qa --yaml \
-               -D "__dbi_txn create nofsync private" \
-               | grep -i 'Packageorigin' | cut -d : -f 2 > ${IMAGE_ROOTFS}/install/install_solution.manifest
-
-       # Attempt install
-       ${RPM} --root ${IMAGE_ROOTFS} -D "_dbpath ${rpmlibdir}" \
-               --noscripts --notriggers --noparentdirs --nolinktos \
-               -D "__dbi_txn create nofsync private" \
-               -Uhv ${IMAGE_ROOTFS}/install/install_solution.manifest
+       package_install_internal_rpm
 
        export D=${IMAGE_ROOTFS}
        export OFFLINE_ROOT=${IMAGE_ROOTFS}
@@ -227,7 +122,7 @@ EOF
 
        # Workaround so the parser knows we need the resolve_package function!
        if false ; then
-               resolve_package foo || true
+               resolve_package_rpm foo ${RPMCONF_TARGET_BASE}.conf || true
        fi
 }
 
@@ -236,18 +131,6 @@ remove_packaging_data_files() {
        rm -rf ${IMAGE_ROOTFS}${opkglibdir}
 }
 
-# Resolve package names to filepaths
-resolve_package() {
-       pkg="$1"
-       pkg_name=""
-       for solve in `cat ${DEPLOY_DIR_RPM}/solvedb.conf`; do
-               pkg_name=$(${RPM} -D "_dbpath $solve" -D "__dbi_txn create nofsync" -q --yaml $pkg | grep -i 'Packageorigin' | cut -d : -f 2)
-               if [ -n "$pkg_name" ]; then
-                       break;
-               fi
-       done
-       echo $pkg_name
-}      
 
 install_all_locales() {
        PACKAGES_TO_INSTALL=""
@@ -263,7 +146,7 @@ install_all_locales() {
        # but this should be good enough for the few users of this function...
        for pkg in $INSTALLED_PACKAGES; do
                for lang in ${IMAGE_LOCALES}; do
-                       pkg_name=$(resolve_package $pkg-locale-$lang)
+                       pkg_name=$(resolve_package_rpm $pkg-locale-$lang ${RPMCONF_TARGET_BASE}.conf)
                        if [ -n "$pkg_name" ]; then
                                ${RPM} --root ${IMAGE_ROOTFS} -D "_dbpath ${rpmlibdir}" \
                                        -D "__dbi_txn create nofsync private" \