#!/bin/bash
# BEGIN COPYRIGHT BLOCK
# (C) 2010 Red Hat, Inc.
# All rights reserved.
# END COPYRIGHT BLOCK

##
## Include common 'compose' functions
##

COMPOSE_PWD=`dirname $0`
source ${COMPOSE_PWD}/compose_functions

## Always switch into the base directory three levels
## above this shell script prior to executing it so
## that all of its output is written to this directory

cd `dirname $0`/../..


##
## Retrieve the name of this base directory
##

PKI_PWD=`pwd`


##
## Establish the 'pki-core' name and version information
##

PKI_CORE="pki-core"
PKI_CORE_VERSION="10.2.6"


##
## Establish the SOURCE files/directories of the 'pki-core' source directory
##

PKI_SPECS_FILE="${PKI_DIR}/specs/${PKI_CORE}.spec"
PKI_COMPONENT_LIST="test symkey util common native-tools java-tools"

if [ "$WITHOUT_JAVADOC" = "" ]; then
    PKI_COMPONENT_LIST="$PKI_COMPONENT_LIST javadoc"
fi

if [ "$WITHOUT_SERVER" = "" ]; then
    PKI_COMPONENT_LIST="$PKI_COMPONENT_LIST server ca kra ocsp tks tps"
    # required for native 'tpsclient' utility
    PKI_COMPONENT_LIST="$PKI_COMPONENT_LIST tps-client"
fi

##
## Establish the TARGET files/directories of the 'pki-core' source/spec files
##

if [ $WORK_DIR ]; then
    PKI_PACKAGES="`cd $WORK_DIR ; pwd`"
else
    PKI_PACKAGES="${PKI_PWD}/packages"
fi

PKI_CORE_BUILD_DIR="${PKI_PACKAGES}/BUILD"
PKI_CORE_RPMS_DIR="${PKI_PACKAGES}/RPMS"
PKI_CORE_SOURCES_DIR="${PKI_PACKAGES}/SOURCES"
PKI_CORE_SPECS_DIR="${PKI_PACKAGES}/SPECS"
PKI_CORE_SRPMS_DIR="${PKI_PACKAGES}/SRPMS"

PKI_CORE_TARBALL="${PKI_CORE}-${PKI_CORE_VERSION}.tar.gz"
PKI_CORE_SPEC_FILE="${PKI_CORE_SPECS_DIR}/${PKI_CORE}.spec"
PKI_CORE_PACKAGE_SCRIPT="${PKI_PACKAGES}/package_${PKI_CORE}"
PKI_CORE_PACKAGE_COMMAND="${RPMBUILD_CMD} SPECS/${PKI_CORE}.spec"

PKI_CORE_STAGING_DIR="${PKI_PACKAGES}/staging"
PKI_CORE_DIR="${PKI_CORE_STAGING_DIR}/${PKI_CORE}-${PKI_CORE_VERSION}"
PKI_CORE_BASE_DIR="${PKI_CORE_DIR}/base"


##
## Always create a top-level 'packages' directory
##

mkdir -p ${PKI_PACKAGES}


##
## Always create 'pki-core' package directories
##

mkdir -p ${PKI_CORE_BUILD_DIR}
mkdir -p ${PKI_CORE_RPMS_DIR}
mkdir -p ${PKI_CORE_SOURCES_DIR}
mkdir -p ${PKI_CORE_SPECS_DIR}
mkdir -p ${PKI_CORE_SRPMS_DIR}


##
## Always start with new 'pki-core' package files
##

rm -rf ${PKI_CORE_BUILD_DIR}/${PKI_CORE}-${PKI_CORE_VERSION}
rm -f  ${PKI_CORE_RPMS_DIR}/${PKI_CORE}-${PKI_CORE_VERSION}*.rpm
rm -f  ${PKI_CORE_SOURCES_DIR}/${PKI_CORE_TARBALL}
rm -f  ${PKI_CORE_SPEC_FILE}
rm -f  ${PKI_CORE_SRPMS_DIR}/${PKI_CORE}-${PKI_CORE_VERSION}*.rpm


##
## Copy a new 'pki-core' spec file from the
## current contents of the PKI working repository
##

cp -p ${PKI_SPECS_FILE} ${PKI_CORE_SPECS_DIR}


##
## If specified, copy all Patches from the spec file URL to SOURCES
##

if [ ${FETCH_PATCH_FILES} -eq 1 ] ; then
	Fetch_Patch_Files ${PKI_SPECS_FILE} ${PKI_CORE_SOURCES_DIR}
fi


##
## Copy the specified Source Tarball from the spec file URL to SOURCES, or
## Generate a fresh Source Tarball from the local source
##

if [ ${FETCH_SOURCE_TARBALL} -eq 1 ] ; then
	Fetch_Source_Tarball ${PKI_SPECS_FILE} ${PKI_CORE_SOURCES_DIR}
else
	##
	## Always start with a new 'pki-core' staging directory
	##

	rm -rf ${PKI_CORE_STAGING_DIR}


	##
	## To generate the 'pki-core' tarball, construct a staging area
	## consisting of the 'pki-core' source components from the
	## current contents of the PKI working repository
	##

	mkdir -p ${PKI_CORE_DIR}
	cd ${PKI_DIR}
	for file in "${PKI_FILE_LIST}" ;
	do
		cp -p ${file} ${PKI_CORE_DIR}
	done
	find ${PKI_CMAKE_DIR}             \
		-name .svn -prune -o          \
		-name *.swp -prune -o         \
		-print | cpio -pdum ${PKI_CORE_DIR} > /dev/null 2>&1
	cd - > /dev/null 2>&1

	mkdir -p ${PKI_CORE_BASE_DIR}
	cd ${PKI_BASE_DIR}
	cp -p ${PKI_BASE_MANIFEST} ${PKI_CORE_BASE_DIR}
	cp -p VERSION ${PKI_CORE_BASE_DIR}
	for component in ${PKI_COMPONENT_LIST} ;
	do
		dest="${component}"

		# copying ${PKI_BASE_DIR}/${component} to ${PKI_CORE_BASE_DIR}/${dest}
		cd ${component}
		mkdir ${PKI_CORE_BASE_DIR}/${dest}

		find                          \
		-name .svn -prune -o          \
		-name *.swp -prune -o         \
		-print | cpio -pdum ${PKI_CORE_BASE_DIR}/${dest} > /dev/null 2>&1

		cd ..
	done
	cd - > /dev/null 2>&1


	##
	## Create the 'pki-core' tarball
	##

	mkdir -p ${PKI_CORE_SOURCES_DIR}
	cd ${PKI_CORE_STAGING_DIR}
	gtar -zcvf ${PKI_CORE_TARBALL}    \
		"${PKI_CORE}-${PKI_CORE_VERSION}" > /dev/null 2>&1
	mv ${PKI_CORE_TARBALL} ${PKI_CORE_SOURCES_DIR}
	cd - > /dev/null 2>&1


	##
	## Always remove the PKI staging area
	##

	rm -rf ${PKI_CORE_STAGING_DIR}
fi


##
## Always generate a fresh 'pki-core' package script
##

rm -rf ${PKI_CORE_PACKAGE_SCRIPT}
printf "#!/bin/bash\n\n"                 >  ${PKI_CORE_PACKAGE_SCRIPT}
printf "${PKI_CORE_PACKAGE_COMMAND}\n\n" >> ${PKI_CORE_PACKAGE_SCRIPT}
chmod 775 ${PKI_CORE_PACKAGE_SCRIPT}


##
## Automatically invoke RPM/SRPM creation
##

cd ${PKI_PACKAGES} ;
bash ./package_${PKI_CORE} | tee package_${PKI_CORE}.log 2>&1

if [ "$CREATEREPO" == "Y" ] ; then
   echo "Creating a repository of the built rpms"
   cp -r $PKI_PWD/$PKI_DIR/scripts/scp_the_repo.exp .
   Create_repo_after_build $REPO_CFG_FILE
fi
