Project

General

Profile

Download (81.6 KB) Statistics
| Branch: | Tag: | Revision:
1
#!/bin/sh
2
#
3
# builder_common.sh
4
#
5
# Copyright (c) 2004-2015 Electric Sheep Fencing, LLC
6
# Copyright (C) 2014 Ermal Luçi
7
# All rights reserved.
8
#
9
# NanoBSD portions of the code
10
# Copyright (c) 2005 Poul-Henning Kamp.
11
# and copied from nanobsd.sh
12
# All rights reserved.
13
#
14
# FreeSBIE portions of the code
15
# Copyright (c) 2005 Dario Freni
16
# and copied from FreeSBIE project
17
# All rights reserved.
18
#
19
# Redistribution and use in source and binary forms, with or without
20
# modification, are permitted provided that the following conditions
21
# are met:
22
#
23
# 1. Redistributions of source code must retain the above copyright
24
#    notice, this list of conditions and the following disclaimer.
25
#
26
# 2. Redistributions in binary form must reproduce the above copyright
27
#    notice, this list of conditions and the following disclaimer in the
28
#    documentation and/or other materials provided with the distribution.
29
#
30
# THIS SOFTWARE IS PROVIDED BY THE pfSense PROJECT ``AS IS'' AND ANY
31
# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
33
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE pfSense PROJECT OR
34
# ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
35
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
37
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
40
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
41
# OF THE POSSIBILITY OF SUCH DAMAGE.
42
# Redistribution and use in source and binary forms, with or without
43
# modification, are permitted provided that the following conditions are met:
44
#
45

    
46
if [ -n "${IMAGES_FINAL_DIR}" -a "${IMAGES_FINAL_DIR}" != "/" ]; then
47
	mkdir -p ${IMAGES_FINAL_DIR}
48
else
49
	echo "IMAGES_FINAL_DIR is not defined"
50
	print_error_pfS
51
fi
52

    
53
lc() {
54
	echo "${1}" | tr '[[:upper:]]' '[[:lower:]]'
55
}
56

    
57
git_last_commit() {
58
	export CURRENT_COMMIT=$(git -C ${BUILDER_ROOT} log -1 --format='%H')
59
	export CURRENT_AUTHOR=$(git -C ${BUILDER_ROOT} log -1 --format='%an')
60
	echo ">>> Last known commit $CURRENT_AUTHOR - $CURRENT_COMMIT"
61
	echo "$CURRENT_COMMIT" > $SCRATCHDIR/build_commit_info.txt
62
}
63

    
64
# Create core pkg repository
65
core_pkg_create_repo() {
66
	if [ ! -d "${CORE_PKG_REAL_PATH}/All" ]; then
67
		return
68
	fi
69

    
70
	############ ATTENTION ##############
71
	#
72
	# For some reason pkg-repo fail without / in the end of directory name
73
	# so removing it will break command
74
	#
75
	# https://github.com/freebsd/pkg/issues/1364
76
	#
77
	echo -n ">>> Creating core packages repository... "
78
	if pkg repo -q "${CORE_PKG_REAL_PATH}/"; then
79
		echo "Done!"
80
	else
81
		echo "Failed!"
82
		print_error_pfS
83
	fi
84

    
85
	# Use the same directory structure as poudriere does to avoid
86
	# breaking snapshot repositories during rsync
87
	ln -sf $(basename ${CORE_PKG_REAL_PATH}) ${CORE_PKG_PATH}/.latest
88
	ln -sf .latest/All ${CORE_PKG_PATH}/All
89
	ln -sf .latest/digests.txz ${CORE_PKG_PATH}/digests.txz
90
	ln -sf .latest/meta.txz ${CORE_PKG_PATH}/meta.txz
91
	ln -sf .latest/packagesite.txz ${CORE_PKG_PATH}/packagesite.txz
92
}
93

    
94
# Create core pkg (base, kernel)
95
core_pkg_create() {
96
	local _template="${1}"
97
	local _flavor="${2}"
98
	local _version="${3}"
99
	local _root="${4}"
100
	local _filter="${5}"
101

    
102
	[ -d "${CORE_PKG_TMP}" ] \
103
		&& rm -rf ${CORE_PKG_TMP}
104

    
105
	local _templates_path=${BUILDER_TOOLS}/templates/core_pkg/${_template}
106
	local _template_metadir=${_templates_path}/metadir
107
	local _metadir=${CORE_PKG_TMP}/${_template}_metadir
108

    
109
	if [ ! -d ${_template_metadir} ]; then
110
		echo "ERROR: Template dir not found for pkg ${_template}"
111
		exit
112
	fi
113

    
114
	mkdir -p ${CORE_PKG_TMP}
115

    
116
	cp -r ${_template_metadir} ${_metadir}
117

    
118
	local _manifest=${_metadir}/+MANIFEST
119
	local _plist=${CORE_PKG_TMP}/${_template}_plist
120
	local _exclude_plist=${CORE_PKG_TMP}/${_template}_exclude_plist
121

    
122
	if [ -f "${_templates_path}/pkg-plist" ]; then
123
		cp ${_templates_path}/pkg-plist ${_plist}
124
	else
125
		if [ -n "${_filter}" ]; then
126
			_filter="-name ${_filter}"
127
		fi
128
		(cd ${_root} && find . ${_filter} -type f -or -type l | sed 's,^.,,' | sort -u) > ${_plist}
129
	fi
130

    
131
	if [ -f "${_templates_path}/exclude_plist" ]; then
132
		cp ${_templates_path}/exclude_plist ${_exclude_plist}
133
	else
134
		touch ${_exclude_plist}
135
	fi
136

    
137
	sed \
138
		-i '' \
139
		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
140
		-e "s,%%PRODUCT_URL%%,${PRODUCT_URL},g" \
141
		-e "s,%%FLAVOR%%,${_flavor:+-}${_flavor},g" \
142
		-e "s,%%FLAVOR_DESC%%,${_flavor:+ (${_flavor})},g" \
143
		-e "s,%%VERSION%%,${_version},g" \
144
		${_metadir}/* \
145
		${_plist} \
146
		${exclude_plist}
147

    
148
	if [ -f "${_exclude_plist}" ]; then
149
		sort -u ${_exclude_plist} > ${_plist}.exclude
150
		mv ${_plist} ${_plist}.tmp
151
		comm -23 ${_plist}.tmp ${_plist}.exclude > ${_plist}
152
		rm -f ${_plist}.tmp ${plist}.exclude
153
	fi
154

    
155
	# Add license information
156
	local _portname=$(sed '/^name: /!d; s,^[^"]*",,; s,",,' ${_metadir}/+MANIFEST)
157
	local _licenses_dir="/usr/local/share/licenses/${_portname}-${_version}"
158
	mkdir -p ${_root}${_licenses_dir}
159
	cp ${BUILDER_ROOT}/license.txt ${_root}${_licenses_dir}/ESF
160
	echo "This package has a single license: ESF (Electric Sheep Fencing License)." \
161
		> ${_root}${_licenses_dir}/LICENSE
162
	cat <<EOF >${_root}${_licenses_dir}/catalog.mk
163
_LICENSE=ESF
164
_LICENSE_NAME=Electric Sheep Fencing License
165
_LICENSE_PERMS=dist-mirror dist-sell pkg-mirror pkg-sell auto-accept
166
_LICENSE_GROUPS=
167
_LICENSE_DISTFILES=
168
EOF
169
	cat <<EOF >>${_plist}
170
${_licenses_dir}/catalog.mk
171
${_licenses_dir}/LICENSE
172
${_licenses_dir}/ESF
173
EOF
174

    
175
	mkdir -p ${CORE_PKG_REAL_PATH}/All
176
	if ! pkg create -o ${CORE_PKG_REAL_PATH}/All -p ${_plist} -r ${_root} -m ${_metadir}; then
177
		echo ">>> ERROR: Error building package ${_template} ${_flavor}"
178
		print_error_pfS
179
	fi
180
}
181

    
182
# This routine will output that something went wrong
183
print_error_pfS() {
184
	echo
185
	echo "####################################"
186
	echo "Something went wrong, check errors!" >&2
187
	echo "####################################"
188
	echo
189
	echo "NOTE: a lot of times you can run './build.sh --clean-builder' to resolve."
190
	echo
191
	if [ "$1" != "" ]; then
192
		echo $1
193
	fi
194
	[ -n "${LOGFILE}" -a -f "${LOGFILE}" ] && \
195
		echo "Log saved on ${LOGFILE}" && \
196
		tail -n20 ${LOGFILE} >&2
197
	echo
198
	kill $$
199
	exit 1
200
}
201

    
202
prestage_on_ram_setup() {
203
	# Do not use memory disks for release build
204
	if [ -n "${_IS_RELEASE}" ]; then
205
		return
206
	fi
207

    
208
	[ -d "${STAGE_CHROOT_DIR}" ] \
209
		|| mkdir -p ${STAGE_CHROOT_DIR}
210
	[ -d "${FINAL_CHROOT_DIR}" ] \
211
		|| mkdir -p ${FINAL_CHROOT_DIR}
212

    
213
	_AVAIL_MEM=$(($(sysctl -n hw.usermem) / 1024 / 1024))
214
	if [ $_AVAIL_MEM -lt 2000 ]; then
215
		echo ">>> Builder has less than 2GiB RAM skipping memory disks"
216
		return
217
	else
218
		echo "######################################################################################"
219
		echo
220
		echo ">>> Builder has more than 2GiB RAM enabling memory disks"
221
		echo ">>> WARNING: Remember to remove these memory disks by running $0 --disable-memorydisks"
222
		echo
223
		echo "######################################################################################"
224
	fi
225

    
226
	if df /dev/ufs/prestagebacking >/dev/null 2>&1; then
227
		echo ">>> Detected preexisting memory disk enabled for ${STAGE_CHROOT_DIR}."
228
	else
229
		mdconfig -a -t swap -u 10001 -s ${MEMORYDISK_SIZE}
230
		newfs -L prestagebacking -U /dev/md10001
231
		mount /dev/ufs/prestagebacking ${STAGE_CHROOT_DIR}
232
	fi
233

    
234
	if df /dev/ufs/finalstagebacking >/dev/null 2>&1; then
235
		echo ">>> Detected preexisting memory disk enabled for ${FINAL_CHROOT_DIR}."
236
	else
237
		mdconfig -a -t swap -u 10002 -s ${MEMORYDISK_SIZE}
238
		newfs -L finalstagebacking -U /dev/md10002
239
		mount /dev/ufs/finalstagebacking ${FINAL_CHROOT_DIR}
240
	fi
241
}
242

    
243
prestage_on_ram_cleanup() {
244
	if [ -c /dev/md10001 ]; then
245
		if [ -d ${STAGE_CHROOT_DIR} ]; then
246
			umount ${STAGE_CHROOT_DIR}
247
		fi
248
		mdconfig -d -u 10001
249
	fi
250
	if [ -c /dev/md10002 ]; then
251
		if [ -d ${FINAL_CHROOT_DIR} ]; then
252
			umount ${FINAL_CHROOT_DIR}
253
		fi
254
		mdconfig -d -u 10002
255
	fi
256
}
257

    
258
# This routine will verify that the kernel has been
259
# installed OK to the staging area.
260
ensure_kernel_exists() {
261
	if [ ! -f "$1/boot/kernel/kernel.gz" ]; then
262
		echo ">>> ERROR: Could not locate $1/boot/kernel.gz"
263
		print_error_pfS
264
	fi
265
	KERNEL_SIZE=$(stat -f "%z" $1/boot/kernel/kernel.gz)
266
	if [ "$KERNEL_SIZE" -lt 3500 ]; then
267
		echo ">>> ERROR: Kernel $1/boot/kernel.gz appears to be smaller than it should be: $KERNEL_SIZE"
268
		print_error_pfS
269
	fi
270
}
271

    
272
get_pkg_name() {
273
	echo "${PRODUCT_NAME}-${1}-${CORE_PKG_VERSION}"
274
}
275

    
276
# This routine builds all related kernels
277
build_all_kernels() {
278
	# Set KERNEL_BUILD_PATH if it has not been set
279
	if [ -z "${KERNEL_BUILD_PATH}" ]; then
280
		KERNEL_BUILD_PATH=$SCRATCHDIR/kernels
281
		echo ">>> KERNEL_BUILD_PATH has not been set. Setting to ${KERNEL_BUILD_PATH}!"
282
	fi
283

    
284
	[ -d "${KERNEL_BUILD_PATH}" ] \
285
		&& rm -rf ${KERNEL_BUILD_PATH}
286

    
287
	# Build embedded kernel
288
	for BUILD_KERNEL in $BUILD_KERNELS; do
289
		unset KERNCONF
290
		unset KERNEL_DESTDIR
291
		unset KERNELCONF
292
		unset KERNEL_NAME
293
		export KERNCONF=$BUILD_KERNEL
294
		export KERNEL_DESTDIR="$KERNEL_BUILD_PATH/$BUILD_KERNEL"
295
		export KERNELCONF="${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/$BUILD_KERNEL"
296
		export KERNEL_NAME=${BUILD_KERNEL}
297

    
298
		LOGFILE="${BUILDER_LOGS}/kernel.${KERNCONF}.${TARGET}.log"
299
		echo ">>> Building $BUILD_KERNEL kernel."  | tee -a ${LOGFILE}
300

    
301
		if [ ! -e "${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/${BUILD_KERNEL}" ]; then
302
			echo ">>> ERROR: Could not find $KERNELCONF"
303
			print_error_pfS
304
		fi
305

    
306
		if [ -n "${NO_BUILDKERNEL}" -a -f "${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz" ]; then
307
			echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}
308
			continue
309
		fi
310

    
311
		export SRC_CONF=${SRC_CONF}
312
		buildkernel
313

    
314
		echo ">>> Staging $BUILD_KERNEL kernel..." | tee -a ${LOGFILE}
315
		installkernel
316

    
317
		ensure_kernel_exists $KERNEL_DESTDIR
318

    
319
		echo -n ">>> Creating pkg of $KERNEL_NAME-debug kernel to staging area..."  | tee -a ${LOGFILE}
320
		core_pkg_create kernel-debug ${KERNEL_NAME} ${CORE_PKG_VERSION} ${KERNEL_DESTDIR} \*.symbols
321
		find ${KERNEL_DESTDIR} -name '*.symbols' -type f -delete
322

    
323
		echo -n ">>> Creating pkg of $KERNEL_NAME kernel to staging area..."  | tee -a ${LOGFILE}
324
		core_pkg_create kernel ${KERNEL_NAME} ${CORE_PKG_VERSION} ${KERNEL_DESTDIR}
325

    
326
		rm -rf $KERNEL_DESTDIR 2>&1 1>/dev/null
327

    
328
		echo ".Done" | tee -a ${LOGFILE}
329
	done
330
}
331

    
332
install_default_kernel() {
333
	if [ -z "${1}" ]; then
334
		echo ">>> ERROR: install_default_kernel called without a kernel config name"| tee -a ${LOGFILE}
335
		print_error_pfS
336
	fi
337

    
338
	export KERNEL_NAME="${1}"
339

    
340
	echo -n ">>> Installing kernel to be used by image ${KERNEL_NAME}..." | tee -a ${LOGFILE}
341

    
342
	# Copy kernel package to chroot, otherwise pkg won't find it to install
343
	if ! pkg_chroot_add ${FINAL_CHROOT_DIR} kernel-${KERNEL_NAME}; then
344
		echo ">>> ERROR: Error installing kernel package $(get_pkg_name kernel-${KERNEL_NAME}).txz" | tee -a ${LOGFILE}
345
		print_error_pfS
346
	fi
347

    
348
	# Lock kernel to avoid user end up removing it for any reason
349
	pkg_chroot ${FINAL_CHROOT_DIR} lock -q -y $(get_pkg_name kernel-${KERNEL_NAME})
350

    
351
	if [ ! -f $FINAL_CHROOT_DIR/boot/kernel/kernel.gz ]; then
352
		echo ">>> ERROR: No kernel installed on $FINAL_CHROOT_DIR and the resulting image will be unusable. STOPPING!" | tee -a ${LOGFILE}
353
		print_error_pfS
354
	fi
355
	mkdir -p $FINAL_CHROOT_DIR/pkgs
356
	if [ -z "${2}" -o -n "${INSTALL_EXTRA_KERNELS}" ]; then
357
		cp ${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz $FINAL_CHROOT_DIR/pkgs
358
		if [ -n "${INSTALL_EXTRA_KERNELS}" ]; then
359
			for _EXTRA_KERNEL in $INSTALL_EXTRA_KERNELS; do
360
				_EXTRA_KERNEL_PATH=${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${_EXTRA_KERNEL}).txz
361
				if [ -f "${_EXTRA_KERNEL_PATH}" ]; then
362
					echo -n ". adding ${_EXTRA_KERNEL_PATH} on image /pkgs folder"
363
					cp ${_EXTRA_KERNEL_PATH} $FINAL_CHROOT_DIR/pkgs
364
				else
365
					echo ">>> ERROR: Requested kernel $(get_pkg_name kernel-${_EXTRA_KERNEL}).txz was not found to be put on image /pkgs folder!"
366
					print_error_pfS
367
				fi
368
			done
369
		fi
370
	fi
371
	echo "Done." | tee -a ${LOGFILE}
372

    
373
	unset KERNEL_NAME
374
}
375

    
376
# Creates a full update file
377
create_Full_update_tarball() {
378
	mkdir -p $UPDATESDIR
379

    
380
	customize_stagearea_for_image "fullupdate"
381
	install_default_kernel ${DEFAULT_KERNEL}
382

    
383
	rm -rf ${FINAL_CHROOT_DIR}/cf
384
	rm -rf ${FINAL_CHROOT_DIR}/conf
385
	rm -f ${FINAL_CHROOT_DIR}/etc/dh-parameters.*
386
	rm -f ${FINAL_CHROOT_DIR}/etc/rc.conf
387
	rm -f ${FINAL_CHROOT_DIR}/etc/pwd.db 2>/dev/null
388
	rm -f ${FINAL_CHROOT_DIR}/etc/group 2>/dev/null
389
	rm -f ${FINAL_CHROOT_DIR}/etc/spwd.db 2>/dev/null
390
	rm -f ${FINAL_CHROOT_DIR}/etc/passwd 2>/dev/null
391
	rm -f ${FINAL_CHROOT_DIR}/etc/master.passwd 2>/dev/null
392
	rm -f ${FINAL_CHROOT_DIR}/etc/fstab 2>/dev/null
393
	rm -f ${FINAL_CHROOT_DIR}/etc/bogons 2>/dev/null
394
	# Remove loader.conf and friends.  Ticket #560
395
	rm ${FINAL_CHROOT_DIR}/boot/loader.conf 2>/dev/null
396
	rm ${FINAL_CHROOT_DIR}/boot/loader.conf.local 2>/dev/null
397

    
398
	# Old systems will run (pre|post)_upgrade_command from /tmp
399
	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command ]; then
400
		cp -p \
401
			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command \
402
			${FINAL_CHROOT_DIR}/tmp
403
	fi
404
	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command ]; then
405
		cp -p \
406
			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command \
407
			${FINAL_CHROOT_DIR}/tmp
408
	fi
409

    
410
	echo ">>> Creating ${UPDATES_TARBALL_FILENAME} ..." | tee -a ${LOGFILE}
411
	tar --exclude=./dev -czPf ${UPDATES_TARBALL_FILENAME} -C ${FINAL_CHROOT_DIR} .
412
}
413

    
414
# Outputs various set variables aka env
415
print_flags() {
416

    
417
	echo
418
	printf "             Product version: %s\n" $PRODUCT_VERSION
419
	printf "                   Stage DIR: %s\n" $STAGE_CHROOT_DIR
420
	printf "                 Updates dir: %s\n" $UPDATESDIR
421
	printf " Image Preparation Stage DIR: %s\n" $FINAL_CHROOT_DIR
422
	printf "                  Source DIR: %s\n" $FREEBSD_SRC_DIR
423
	printf "          FreeBSD repository: %s\n" $FREEBSD_REPO_BASE
424
	printf "          FreeBSD-src branch: %s\n" $FREEBSD_BRANCH
425
	printf "     FreeBSD original branch: %s\n" $FREEBSD_PARENT_BRANCH
426
	printf "               BUILD_KERNELS: %s\n" $BUILD_KERNELS
427
	printf "           Git Branch or Tag: %s\n" $GIT_REPO_BRANCH_OR_TAG
428
	printf "            MODULES_OVERRIDE: %s\n" $MODULES_OVERRIDE
429
	printf "    VMDK_DISK_CAPACITY_IN_GB: %s\n" $VMDK_DISK_CAPACITY_IN_GB
430
	printf "                 OVFTEMPLATE: %s\n" $OVFTEMPLATE
431
	printf "                     OVFVMDK: %s\n" $OVFVMDK
432
	printf "                    SRC_CONF: %s\n" $SRC_CONF
433
	printf "                     ISOPATH: %s\n" $ISOPATH
434
	printf "                MEMSTICKPATH: %s\n" $MEMSTICKPATH
435
	printf "    UPDATES_TARBALL_FILENAME: %s\n" $UPDATES_TARBALL_FILENAME
436
if [ -n "$SHOW_ENV" ]; then
437
	for LINE in $(env | egrep -v '(terminal|PASS|NAME|USER|SSH|GROUP|HOST)'); do
438
		echo "SHOW_ENV: $LINE"
439
	done
440
fi
441
	echo
442
}
443

    
444
# This builds FreeBSD (make buildworld)
445
# Imported from FreeSBIE
446
make_world() {
447

    
448
	LOGFILE=${BUILDER_LOGS}/buildworld.${TARGET}
449
	if [ -n "${NO_BUILDWORLD}" ]; then
450
		echo ">>> NO_BUILDWORLD set, skipping build" | tee -a ${LOGFILE}
451
		return
452
	fi
453

    
454
	# Set SRC_CONF variable if it's not already set.
455
	if [ -z "${SRC_CONF}" ]; then
456
		echo ">>> SRC_CONF is unset make sure this is what you want!" | tee -a ${LOGFILE}
457
	else
458
		echo ">>> Setting SRC_CONF to $SRC_CONF" | tee -a ${LOGFILE}
459
	fi
460

    
461
	# Set default parameters
462
	export MAKE_ARGS="${MAKEJ_WORLD} __MAKE_CONF=${MAKE_CONF} SRCCONF=${SRC_CONF} TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH}"
463

    
464
	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}
465
	makeargs="${MAKE_ARGS}"
466
	echo ">>> Building world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
467
	echo ">>> Builder is running the command: env LOCAL_ITOOLS=\"${EXTRA_TOOLS}\" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_CLEAN ${makeargs} buildworld" | tee -a ${LOGFILE}
468
	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_CLEAN ${makeargs} buildworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
469
	echo ">>> Building world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
470

    
471
	LOGFILE=${BUILDER_LOGS}/installworld.${TARGET}
472
	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}
473
	# Create if cleaned up
474
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR} WITHOUT_TOOLCHAIN=1"
475
	echo ">>> Installing world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
476
	echo ">>> Builder is running the command: env LOCAL_ITOOLS=\"${EXTRA_TOOLS}\" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld" | tee -a ${LOGFILE}
477
	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
478
	echo ">>> Installing world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
479

    
480
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"
481
	echo ">>> Distribution world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
482
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution " | tee -a ${LOGFILE}
483
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution  || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
484
	echo ">>> Distribution world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
485

    
486
	[ -d "${STAGE_CHROOT_DIR}/usr/local/bin" ] \
487
		|| mkdir -p ${STAGE_CHROOT_DIR}/usr/local/bin
488
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"
489
	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
490
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install " | tee -a ${LOGFILE}
491
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
492
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean" | tee -a ${LOGFILE}
493
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
494
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} all" | tee -a ${LOGFILE}
495
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} all || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
496
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} install" | tee -a ${LOGFILE}
497
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
498
	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
499

    
500
	unset makeargs
501
}
502

    
503
nanobsd_image_filename() {
504
	local _size="$1"
505
	local _type="$2"
506
	local _upgrade="$3"
507

    
508
	if [ -z "$_upgrade" ]; then
509
		local _template=${NANOBSD_IMG_TEMPLATE}
510
	else
511
		local _template=${NANOBSD_UPGRADE_TEMPLATE}
512
	fi
513

    
514
	echo "$_template" | sed \
515
		-e "s,%%SIZE%%,${_size},g" \
516
		-e "s,%%TYPE%%,${_type},g"
517

    
518
	return 0
519
}
520

    
521
# This routine originated in nanobsd.sh
522
nanobsd_set_flash_details () {
523
	a1=$(echo $1 | tr '[:upper:]' '[:lower:]')
524

    
525
	# Source:
526
	#	SanDisk CompactFlash Memory Card
527
	#	Product Manual
528
	#	Version 10.9
529
	#	Document No. 20-10-00038
530
	#	April 2005
531
	# Table 2-7
532
	# NB: notice math error in SDCFJ-4096-388 line.
533
	#
534
	case "${a1}" in
535
		2048|2048m|2048mb|2g)
536
			NANO_MEDIASIZE=$((1989999616/512))
537
			;;
538
		4096|4096m|4096mb|4g)
539
			NANO_MEDIASIZE=$((3989999616/512))
540
			;;
541
		8192|8192m|8192mb|8g)
542
			NANO_MEDIASIZE=$((7989999616/512))
543
			;;
544
		16384|16384m|16384mb|16g)
545
			NANO_MEDIASIZE=$((15989999616/512))
546
			;;
547
		*)
548
			echo "Unknown Flash capacity"
549
			exit 2
550
			;;
551
	esac
552

    
553
	NANO_HEADS=16
554
	NANO_SECTS=63
555

    
556
	echo ">>> [nanoo] $1"
557
	echo ">>> [nanoo] NANO_MEDIASIZE: $NANO_MEDIASIZE"
558
	echo ">>> [nanoo] NANO_HEADS: $NANO_HEADS"
559
	echo ">>> [nanoo] NANO_SECTS: $NANO_SECTS"
560
	echo ">>> [nanoo] NANO_BOOT0CFG: $NANO_BOOT0CFG"
561
}
562

    
563
# This routine originated in nanobsd.sh
564
create_nanobsd_diskimage () {
565
	if [ -z "${1}" ]; then
566
		echo ">>> ERROR: Type of image has not been specified"
567
		print_error_pfS
568
	fi
569
	if [ -z "${2}" ]; then
570
		echo ">>> ERROR: Size of image has not been specified"
571
		print_error_pfS
572
	fi
573

    
574
	if [ "${1}" = "nanobsd" ]; then
575
		# It's serial
576
		export NANO_BOOTLOADER="boot/boot0sio"
577
	elif [ "${1}" = "nanobsd-vga" ]; then
578
		# It's vga
579
		export NANO_BOOTLOADER="boot/boot0"
580
	else
581
		echo ">>> ERROR: Type of image to create unknown"
582
		print_error_pfS
583
	fi
584

    
585
	if [ -z "${2}" ]; then
586
		echo ">>> ERROR: Media size(s) not specified."
587
		print_error_pfS
588
	fi
589

    
590
	if [ -z "${2}" ]; then
591
		echo ">>> ERROR: FLASH_SIZE is not set."
592
		print_error_pfS
593
	fi
594

    
595
	LOGFILE=${BUILDER_LOGS}/${1}.${TARGET}
596
	# Prepare folder to be put in image
597
	customize_stagearea_for_image "${1}"
598
	install_default_kernel ${DEFAULT_KERNEL} "no"
599

    
600
	echo ">>> Fixing up NanoBSD Specific items..." | tee -a ${LOGFILE}
601

    
602
	echo "nanobsd" > $FINAL_CHROOT_DIR/etc/platform
603

    
604
	local BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
605
	local LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
606

    
607
	if [ "${1}" = "nanobsd" ]; then
608
		# Tell loader to use serial console early.
609
		echo "-S115200 -h" >> ${BOOTCONF}
610

    
611
		# Remove old console options if present.
612
		[ -f "${LOADERCONF}" ] \
613
			&& sed -i "" -Ee "/(console|boot_multicons|boot_serial|hint.uart)/d" ${LOADERCONF}
614
		# Activate serial console+video console in loader.conf
615
		echo 'loader_color="NO"' >> ${LOADERCONF}
616
		echo 'beastie_disable="YES"' >> ${LOADERCONF}
617
		echo 'boot_serial="YES"' >> ${LOADERCONF}
618
		echo 'console="comconsole"' >> ${LOADERCONF}
619
		echo 'comconsole_speed="115200"' >> ${LOADERCONF}
620
	fi
621
	echo 'autoboot_delay="5"' >> ${LOADERCONF}
622

    
623
	for _NANO_MEDIASIZE in ${2}; do
624
		if [ -z "${_NANO_MEDIASIZE}" ]; then
625
			continue;
626
		fi
627

    
628
		echo ">>> building NanoBSD(${1}) disk image with size ${_NANO_MEDIASIZE} for platform (${TARGET})..." | tee -a ${LOGFILE}
629
		echo "" > $BUILDER_LOGS/nanobsd_cmds.sh
630

    
631
		IMG="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1})"
632
		IMGUPDATE="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1} 1)"
633

    
634
		nanobsd_set_flash_details ${_NANO_MEDIASIZE}
635

    
636
		# These are defined in FlashDevice and on builder_default.sh
637
		echo $NANO_MEDIASIZE \
638
			$NANO_IMAGES \
639
			$NANO_SECTS \
640
			$NANO_HEADS \
641
			$NANO_CODESIZE \
642
			$NANO_CONFSIZE \
643
			$NANO_DATASIZE |
644
awk '
645
{
646
	printf "# %s\n", $0
647

    
648
	# size of cylinder in sectors
649
	cs = $3 * $4
650

    
651
	# number of full cylinders on media
652
	cyl = int ($1 / cs)
653

    
654
	# output fdisk geometry spec, truncate cyls to 1023
655
	if (cyl <= 1023)
656
		print "g c" cyl " h" $4 " s" $3
657
	else
658
		print "g c" 1023 " h" $4 " s" $3
659

    
660
	if ($7 > 0) {
661
		# size of data partition in full cylinders
662
		dsl = int (($7 + cs - 1) / cs)
663
	} else {
664
		dsl = 0;
665
	}
666

    
667
	# size of config partition in full cylinders
668
	csl = int (($6 + cs - 1) / cs)
669

    
670
	if ($5 == 0) {
671
		# size of image partition(s) in full cylinders
672
		isl = int ((cyl - dsl - csl) / $2)
673
	} else {
674
		isl = int (($5 + cs - 1) / cs)
675
	}
676

    
677
	# First image partition start at second track
678
	print "p 1 165 " $3, isl * cs - $3
679
	c = isl * cs;
680

    
681
	# Second image partition (if any) also starts offset one
682
	# track to keep them identical.
683
	if ($2 > 1) {
684
		print "p 2 165 " $3 + c, isl * cs - $3
685
		c += isl * cs;
686
	}
687

    
688
	# Config partition starts at cylinder boundary.
689
	print "p 3 165 " c, csl * cs
690
	c += csl * cs
691

    
692
	# Data partition (if any) starts at cylinder boundary.
693
	if ($7 > 0) {
694
		print "p 4 165 " c, dsl * cs
695
	} else if ($7 < 0 && $1 > c) {
696
		print "p 4 165 " c, $1 - c
697
	} else if ($1 < c) {
698
		print "Disk space overcommitted by", \
699
		    c - $1, "sectors" > "/dev/stderr"
700
		exit 2
701
	}
702

    
703
	# Force slice 1 to be marked active. This is necessary
704
	# for booting the image from a USB device to work.
705
	print "a 1"
706
}
707
	' > ${IMAGES_FINAL_DIR}/_.fdisk
708

    
709
		MNT=${IMAGES_FINAL_DIR}/_.mnt
710
		mkdir -p ${MNT}
711

    
712
		dd if=/dev/zero of=${IMG} bs=${NANO_SECTS}b \
713
			count=0 seek=$((${NANO_MEDIASIZE}/${NANO_SECTS})) 2>&1 >> ${LOGFILE}
714

    
715
		MD=$(mdconfig -a -t vnode -f ${IMG} -x ${NANO_SECTS} -y ${NANO_HEADS})
716
		trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
717

    
718
		fdisk -i -f ${IMAGES_FINAL_DIR}/_.fdisk ${MD} 2>&1 >> ${LOGFILE}
719
		fdisk ${MD} 2>&1 >> ${LOGFILE}
720

    
721
		boot0cfg -t 100 -B -b ${FINAL_CHROOT_DIR}/${NANO_BOOTLOADER} ${NANO_BOOT0CFG} ${MD} 2>&1 >> ${LOGFILE}
722

    
723
		# Create first image
724
		bsdlabel -m i386 -w -B -b ${FINAL_CHROOT_DIR}/boot/boot ${MD}s1 2>&1 >> ${LOGFILE}
725
		bsdlabel -m i386 ${MD}s1 2>&1 >> ${LOGFILE}
726
		local _label=$(lc ${PRODUCT_NAME})
727
		newfs -L ${_label}0 ${NANO_NEWFS} /dev/${MD}s1a 2>&1 >> ${LOGFILE}
728
		mount /dev/ufs/${_label}0 ${MNT}
729
		if [ $? -ne 0 ]; then
730
			echo ">>> ERROR: Something wrong happened during mount of first slice image creation. STOPPING!" | tee -a ${LOGFILE}
731
			print_error_pfS
732
		fi
733
		# Consider the unmounting as well
734
		trap "umount /dev/ufs/${_label}0; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
735

    
736
		clone_directory_contents ${FINAL_CHROOT_DIR} ${MNT}
737

    
738
		# Set NanoBSD image size
739
		echo "${_NANO_MEDIASIZE}" > ${MNT}/etc/nanosize.txt
740

    
741
		echo "/dev/ufs/${_label}0 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab
742
		if [ $NANO_CONFSIZE -gt 0 ] ; then
743
			echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab
744
		fi
745

    
746
		umount ${MNT}
747
		# Restore the original trap
748
		trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
749

    
750
		# Setting NANO_IMAGES to 1 and NANO_INIT_IMG2 will tell
751
		# NanoBSD to only create one partition.  We default to 2
752
		# partitions in case anything happens to the first the
753
		# operator can boot from the 2nd and should be OK.
754

    
755
		# Before just going to use dd for duplicate think!
756
		# The images are created as sparse so lets take advantage
757
		# of that by just exec some commands.
758
		if [ $NANO_IMAGES -gt 1 -a $NANO_INIT_IMG2 -gt 0 ] ; then
759
			# Duplicate to second image (if present)
760
			echo ">>> Creating NanoBSD second slice by duplicating first slice." | tee -a ${LOGFILE}
761
			# Create second image
762
			dd if=/dev/${MD}s1 of=/dev/${MD}s2 conv=sparse bs=64k 2>&1 >> ${LOGFILE}
763
			tunefs -L ${_label}1 /dev/${MD}s2a 2>&1 >> ${LOGFILE}
764
			mount /dev/ufs/${_label}1 ${MNT}
765
			if [ $? -ne 0 ]; then
766
				echo ">>> ERROR: Something wrong happened during mount of second slice image creation. STOPPING!" | tee -a ${LOGFILE}
767
				print_error_pfS
768
			fi
769
			# Consider the unmounting as well
770
			trap "umount /dev/ufs/${_label}1; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
771

    
772
			echo "/dev/ufs/${_label}1 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab
773
			if [ $NANO_CONFSIZE -gt 0 ] ; then
774
				echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab
775
			fi
776

    
777
			umount ${MNT}
778
			# Restore the trap back
779
			trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
780
		fi
781

    
782
		# Create Data slice, if any.
783
		# Note the changing of the variable to NANO_CONFSIZE
784
		# from NANO_DATASIZE.  We also added glabel support
785
		# and populate the Product configuration from the /cf
786
		# directory located in FINAL_CHROOT_DIR
787
		if [ $NANO_CONFSIZE -gt 0 ] ; then
788
			echo ">>> Creating /cf area to hold config.xml"
789
			newfs -L cf ${NANO_NEWFS} /dev/${MD}s3 2>&1 >> ${LOGFILE}
790
			# Mount data partition and copy contents of /cf
791
			# Can be used later to create custom default config.xml while building
792
			mount /dev/ufs/cf ${MNT}
793
			if [ $? -ne 0 ]; then
794
				echo ">>> ERROR: Something wrong happened during mount of cf slice image creation. STOPPING!" | tee -a ${LOGFILE}
795
				print_error_pfS
796
			fi
797
			# Consider the unmounting as well
798
			trap "umount /dev/ufs/cf; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
799

    
800
			clone_directory_contents ${FINAL_CHROOT_DIR}/cf ${MNT}
801

    
802
			umount ${MNT}
803
			# Restore the trap back
804
			trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
805
		else
806
			">>> [nanoo] NANO_CONFSIZE is not set. Not adding a /conf partition.. You sure about this??" | tee -a ${LOGFILE}
807
		fi
808

    
809
		echo ">>> [nanoo] Creating NanoBSD upgrade file from first slice..." | tee -a ${LOGFILE}
810
		dd if=/dev/${MD}s1 of=$IMGUPDATE conv=sparse bs=64k 2>&1 >> ${LOGFILE}
811

    
812
		mdconfig -d -u $MD
813
		# Restore default action
814
		trap "-" 1 2 15 EXIT
815

    
816
		# Check each image and ensure that they are over
817
		# 3 megabytes.  If either image is under 20 megabytes
818
		# in size then error out.
819
		IMGSIZE=$(stat -f "%z" ${IMG})
820
		IMGUPDATESIZE=$(stat -f "%z" ${IMGUPDATE})
821
		CHECKSIZE="20040710"
822
		if [ "$IMGSIZE" -lt "$CHECKSIZE" ]; then
823
			echo ">>> ERROR: Something went wrong when building NanoBSD.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}
824
			print_error_pfS
825
		fi
826
		if [ "$IMGUPDATESIZE" -lt "$CHECKSIZE" ]; then
827
			echo ">>> ERROR: Something went wrong when building NanoBSD upgrade image.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}
828
			print_error_pfS
829
		fi
830

    
831
		# Wrap up the show, Johnny
832
		echo ">>> NanoBSD Image completed for size: $_NANO_MEDIASIZE." | tee -a ${LOGFILE}
833

    
834
		gzip -qf $IMG &
835
		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
836
		gzip -qf $IMGUPDATE &
837
		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
838
	done
839

    
840
	unset IMG
841
	unset IMGUPDATE
842
	unset IMGUPDATESIZE
843
	unset IMGSIZE
844

    
845
	ls -lah $IMAGES_FINAL_DIR
846
}
847

    
848
# This routine creates a ova image that contains
849
# a ovf and vmdk file. These files can be imported
850
# right into vmware or virtual box.
851
# (and many other emulation platforms)
852
# http://www.vmware.com/pdf/ovf_whitepaper_specification.pdf
853
create_ova_image() {
854
	# XXX create a .ovf php creator that you can pass:
855
	#     1. populatedSize
856
	#     2. license
857
	#     3. product name
858
	#     4. version
859
	#     5. number of network interface cards
860
	#     6. allocationUnits
861
	#     7. capacity
862
	#     8. capacityAllocationUnits
863

    
864
	LOGFILE=${BUILDER_LOGS}/ova.${TARGET}.log
865

    
866
	[ -d "${OVA_TMP}" ] \
867
		&& rm -rf ${OVA_TMP}
868

    
869
	mkdir -p ${OVA_TMP}
870

    
871
	if [ -z "${OVA_SWAP_PART_SIZE_IN_GB}" -o "${OVA_SWAP_PART_SIZE_IN_GB}" = "0" ]; then
872
		# first partition size (freebsd-ufs)
873
		local OVA_FIRST_PART_SIZE_IN_GB=${VMDK_DISK_CAPACITY_IN_GB}
874
		# Calculate real first partition size, removing 128 blocks (65536 bytes) beginning/loader
875
		local OVA_FIRST_PART_SIZE=$((${OVA_FIRST_PART_SIZE_IN_GB}*1024*1024*1024-65536))
876
		# Unset swap partition size variable
877
		unset OVA_SWAP_PART_SIZE
878
		# Parameter used by mkimg
879
		unset OVA_SWAP_PART_PARAM
880
	else
881
		# first partition size (freebsd-ufs)
882
		local OVA_FIRST_PART_SIZE_IN_GB=$((VMDK_DISK_CAPACITY_IN_GB-OVA_SWAP_PART_SIZE_IN_GB))
883
		# Use first partition size in g
884
		local OVA_FIRST_PART_SIZE="${OVA_FIRST_PART_SIZE_IN_GB}g"
885
		# Calculate real swap size, removing 128 blocks (65536 bytes) beginning/loader
886
		local OVA_SWAP_PART_SIZE=$((${OVA_SWAP_PART_SIZE_IN_GB}*1024*1024*1024-65536))
887
		# Parameter used by mkimg
888
		local OVA_SWAP_PART_PARAM="-p freebsd-swap/swap0::${OVA_SWAP_PART_SIZE}"
889
	fi
890

    
891
	# Prepare folder to be put in image
892
	customize_stagearea_for_image "ova"
893
	install_default_kernel ${DEFAULT_KERNEL} "no"
894

    
895
	# Fill fstab
896
	echo ">>> Installing platform specific items..." | tee -a ${LOGFILE}
897
	echo "/dev/gpt/${PRODUCT_NAME}	/	ufs		rw	1	1" > ${FINAL_CHROOT_DIR}/etc/fstab
898
	if [ -n "${OVA_SWAP_PART_SIZE}" ]; then
899
		echo "/dev/gpt/swap0	none	swap	sw	0	0" >> ${FINAL_CHROOT_DIR}/etc/fstab
900
	fi
901

    
902
	# Create / partition
903
	echo -n ">>> Creating / partition... " | tee -a ${LOGFILE}
904
	makefs \
905
		-B little \
906
		-o label=${PRODUCT_NAME},version=2 \
907
		-s ${OVA_FIRST_PART_SIZE} \
908
		${OVA_TMP}/${OVFUFS} \
909
		${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
910

    
911
	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFUFS} ]; then
912
		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
913
			rm -f ${OVA_TMP}/${OVFUFS}
914
		fi
915
		echo "Failed!" | tee -a ${LOGFILE}
916
		echo ">>> ERROR: Error creating vmdk / partition. STOPPING!" | tee -a ${LOGFILE}
917
		print_error_pfS
918
	fi
919
	echo "Done!" | tee -a ${LOGFILE}
920

    
921
	echo -n ">>> Enabling SUJ on recently created disk... " | tee -a ${LOGFILE}
922
	if ! tunefs -j enable ${OVA_TMP}/${OVFUFS} 2>&1 >>${LOGFILE}; then
923
		echo "Failed!" | tee -a ${LOGFILE}
924
		echo ">>> ERROR: Error enabling SUJ on disk. STOPPING!" | tee -a ${LOGFILE}
925
		print_error_pfS
926
	fi
927
	echo "Done!" | tee -a ${LOGFILE}
928

    
929
	# Create raw disk
930
	echo -n ">>> Creating raw disk... " | tee -a ${LOGFILE}
931
	mkimg \
932
		-s gpt \
933
		-f raw \
934
		-b /boot/pmbr \
935
		-p freebsd-boot:=/boot/gptboot \
936
		-p freebsd-ufs/${PRODUCT_NAME}:=${OVA_TMP}/${OVFUFS} \
937
		${OVA_SWAP_PART_PARAM} \
938
		-o ${OVA_TMP}/${OVFRAW} 2>&1 >> ${LOGFILE}
939

    
940
	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFRAW} ]; then
941
		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
942
			rm -f ${OVA_TMP}/${OVFUFS}
943
		fi
944
		if [ -f ${OVA_TMP}/${OVFRAW} ]; then
945
			rm -f ${OVA_TMP}/${OVFRAW}
946
		fi
947
		echo "Failed!" | tee -a ${LOGFILE}
948
		echo ">>> ERROR: Error creating temporary vmdk image. STOPPING!" | tee -a ${LOGFILE}
949
		print_error_pfS
950
	fi
951
	echo "Done!" | tee -a ${LOGFILE}
952

    
953
	# We don't need it anymore
954
	rm -f ${OVA_TMP}/${OVFUFS} >/dev/null 2>&1
955

    
956
	# Convert raw to vmdk
957
	echo -n ">>> Creating vmdk disk... " | tee -a ${LOGFILE}
958
	vmdktool -z9 -v ${OVA_TMP}/${OVFVMDK} ${OVA_TMP}/${OVFRAW}
959

    
960
	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFVMDK} ]; then
961
		if [ -f ${OVA_TMP}/${OVFRAW} ]; then
962
			rm -f ${OVA_TMP}/${OVFRAW}
963
		fi
964
		if [ -f ${OVA_TMP}/${OVFVMDK} ]; then
965
			rm -f ${OVA_TMP}/${OVFVMDK}
966
		fi
967
		echo "Failed!" | tee -a ${LOGFILE}
968
		echo ">>> ERROR: Error creating vmdk image. STOPPING!" | tee -a ${LOGFILE}
969
		print_error_pfS
970
	fi
971
	echo "Done!" | tee -a ${LOGFILE}
972

    
973
	rm -f ${OVA_TMP}/i${OVFRAW}
974

    
975
	ova_setup_ovf_template
976

    
977
	echo -n ">>> Writing final ova image... " | tee -a ${LOGFILE}
978
	# Create OVA file for vmware
979
	gtar -C ${OVA_TMP} -cpf ${OVAPATH} ${PRODUCT_NAME}.ovf ${OVFVMDK}
980
	echo "Done!" | tee -a ${LOGFILE}
981
	rm -f ${OVA_TMP}/${OVFVMDK} >/dev/null 2>&1
982

    
983
	echo ">>> OVA created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
984
}
985

    
986
# called from create_ova_image
987
ova_setup_ovf_template() {
988
	if [ ! -f ${OVFTEMPLATE} ]; then
989
		echo ">>> ERROR: OVF template file (${OVFTEMPLATE}) not found."
990
		print_error_pfS
991
	fi
992

    
993
	#  OperatingSystemSection (${PRODUCT_NAME}.ovf)
994
	#  42   FreeBSD 32-Bit
995
	#  78   FreeBSD 64-Bit
996
	if [ "${TARGET}" = "amd64" ]; then
997
		local _os_id="78"
998
		local _os_type="freebsd64Guest"
999
		local _os_descr="FreeBSD 64-Bit"
1000
	elif [ "${TARGET}" = "i386" ]; then
1001
		local _os_id="42"
1002
		local _os_type="freebsdGuest"
1003
		local _os_descr="FreeBSD"
1004
	else
1005
		echo ">>> ERROR: Platform not supported for OVA (${TARGET})"
1006
		print_error_pfS
1007
	fi
1008

    
1009
	local POPULATED_SIZE=$(du -d0 -k $FINAL_CHROOT_DIR | cut -f1)
1010
	local POPULATED_SIZE_IN_BYTES=$((${POPULATED_SIZE}*1024))
1011
	local VMDK_FILE_SIZE=$(stat -f "%z" ${OVA_TMP}/${OVFVMDK})
1012

    
1013
	sed \
1014
		-e "s,%%VMDK_FILE_SIZE%%,${VMDK_FILE_SIZE},g" \
1015
		-e "s,%%VMDK_DISK_CAPACITY_IN_GB%%,${VMDK_DISK_CAPACITY_IN_GB},g" \
1016
		-e "s,%%POPULATED_SIZE_IN_BYTES%%,${POPULATED_SIZE_IN_BYTES},g" \
1017
		-e "s,%%OS_ID%%,${_os_id},g" \
1018
		-e "s,%%OS_TYPE%%,${_os_type},g" \
1019
		-e "s,%%OS_DESCR%%,${_os_descr},g" \
1020
		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
1021
		-e "s,%%PRODUCT_NAME_SUFFIX%%,${PRODUCT_NAME_SUFFIX},g" \
1022
		-e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION},g" \
1023
		-e "s,%%PRODUCT_URL%%,${PRODUCT_URL},g" \
1024
		-e "s#%%VENDOR_NAME%%#${VENDOR_NAME}#g" \
1025
		-e "s#%%OVF_INFO%%#${OVF_INFO}#g" \
1026
		-e "/^%%PRODUCT_LICENSE%%/r ${BUILDER_ROOT}/license.txt" \
1027
		-e "/^%%PRODUCT_LICENSE%%/d" \
1028
		${OVFTEMPLATE} > ${OVA_TMP}/${PRODUCT_NAME}.ovf
1029
}
1030

    
1031
# Cleans up previous builds
1032
clean_builder() {
1033
	# Clean out directories
1034
	echo ">>> Cleaning up previous build environment...Please wait!"
1035

    
1036
	staginareas_clean_each_run
1037

    
1038
	if [ -d "${STAGE_CHROOT_DIR}" ]; then
1039
		BASENAME=$(basename ${STAGE_CHROOT_DIR})
1040
		echo -n ">>> Cleaning ${STAGE_CHROOT_DIR} ..."
1041
		chflags -R noschg ${STAGE_CHROOT_DIR} 2>&1 >/dev/null
1042
		rm -rf ${STAGE_CHROOT_DIR}/* 2>/dev/null
1043
		echo "Done."
1044
	fi
1045

    
1046
	if [ -z "${NO_CLEAN_FREEBSD_OBJ}" -a -d "${FREEBSD_SRC_DIR}" ]; then
1047
		OBJTREE=$(env TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} make -C ${FREEBSD_SRC_DIR} -V OBJTREE)
1048
		if [ -d "${OBJTREE}" ]; then
1049
			echo -n ">>> Cleaning FreeBSD objects dir staging..."
1050
			echo -n "."
1051
			chflags -R noschg ${OBJTREE} 2>&1 >/dev/null
1052
			echo -n "."
1053
			rm -rf ${OBJTREE}/*
1054
			echo "Done!"
1055
		fi
1056
		if [ -d "${KERNEL_BUILD_PATH}" ]; then
1057
			echo -n ">>> Cleaning previously built kernel stage area..."
1058
			rm -rf $KERNEL_BUILD_PATH/*
1059
			echo "Done!"
1060
		fi
1061
	fi
1062
	mkdir -p $KERNEL_BUILD_PATH
1063

    
1064
	echo -n ">>> Cleaning previously built images..."
1065
	rm -rf $IMAGES_FINAL_DIR/*
1066
	rm -rf $STAGINGAREA/*
1067
	echo "Done!"
1068

    
1069
	if [ -z "${NO_CLEAN_FREEBSD_SRC}" ]; then
1070
		if [ -d "$FREEBSD_SRC_DIR" ]; then
1071
			echo -n ">>> Ensuring $FREEBSD_SRC_DIR is clean..."
1072
			rm -rf ${FREEBSD_SRC_DIR}
1073
			echo "Done!"
1074
		fi
1075
	fi
1076

    
1077
	echo -n ">>> Cleaning previous builder logs..."
1078
	if [ -d "$BUILDER_LOGS" ]; then
1079
		rm -rf ${BUILDER_LOGS}
1080
	fi
1081
	mkdir -p ${BUILDER_LOGS}
1082

    
1083
	echo "Done!"
1084

    
1085
	echo ">>> Cleaning of builder environment has finished."
1086
}
1087

    
1088
clone_directory_contents() {
1089
	if [ ! -e "$2" ]; then
1090
		mkdir -p "$2"
1091
	fi
1092
	if [ ! -d "$1" -o ! -d "$2" ]; then
1093
		if [ -z "${LOGFILE}" ]; then
1094
			echo ">>> ERROR: Argument $1 supplied is not a directory!"
1095
		else
1096
			echo ">>> ERROR: Argument $1 supplied is not a directory!" | tee -a ${LOGFILE}
1097
		fi
1098
		print_error_pfS
1099
	fi
1100
	echo -n ">>> Using TAR to clone $1 to $2 ..."
1101
	tar -C ${1} -c -f - . | tar -C ${2} -x -p -f -
1102
	echo "Done!"
1103
}
1104

    
1105
clone_to_staging_area() {
1106
	# Clone everything to the final staging area
1107
	echo -n ">>> Cloning everything to ${STAGE_CHROOT_DIR} staging area..."
1108
	LOGFILE=${BUILDER_LOGS}/cloning.${TARGET}.log
1109

    
1110
	tar -C ${PRODUCT_SRC} -c -f - . | \
1111
		tar -C ${STAGE_CHROOT_DIR} -x -p -f -
1112

    
1113
	if [ "${PRODUCT_NAME}" != "pfSense" ]; then
1114
		mv ${STAGE_CHROOT_DIR}/usr/local/sbin/pfSense-upgrade \
1115
			${STAGE_CHROOT_DIR}/usr/local/sbin/${PRODUCT_NAME}-upgrade
1116
	fi
1117

    
1118
	if [ -f ${STAGE_CHROOT_DIR}/etc/master.passwd ]; then
1119
		chroot ${STAGE_CHROOT_DIR} pwd_mkdb /etc/master.passwd
1120
	fi
1121
	mkdir -p ${STAGE_CHROOT_DIR}/etc/mtree
1122
	mtree -Pcp ${STAGE_CHROOT_DIR}/var > ${STAGE_CHROOT_DIR}/etc/mtree/var.dist
1123
	mtree -Pcp ${STAGE_CHROOT_DIR}/etc > ${STAGE_CHROOT_DIR}/etc/mtree/etc.dist
1124
	if [ -d ${STAGE_CHROOT_DIR}/usr/local/etc ]; then
1125
		mtree -Pcp ${STAGE_CHROOT_DIR}/usr/local/etc > ${STAGE_CHROOT_DIR}/etc/mtree/localetc.dist
1126
	fi
1127

    
1128
	## Add buildtime and lastcommit information
1129
	# This is used for detecting updates.
1130
	echo "$BUILTDATESTRING" > $STAGE_CHROOT_DIR/etc/version.buildtime
1131
	# Record last commit info if it is available.
1132
	if [ -f $SCRATCHDIR/build_commit_info.txt ]; then
1133
		cp $SCRATCHDIR/build_commit_info.txt $STAGE_CHROOT_DIR/etc/version.lastcommit
1134
	fi
1135

    
1136
	local _exclude_files="${CORE_PKG_TMP}/base_exclude_files"
1137
	sed \
1138
		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
1139
		-e "s,%%VERSION%%,${_version},g" \
1140
		${BUILDER_TOOLS}/templates/core_pkg/base/exclude_files \
1141
		> ${_exclude_files}
1142

    
1143
	mkdir -p ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR} >/dev/null 2>&1
1144

    
1145
	# Include a sample pkg stable conf to base
1146
	setup_pkg_repo \
1147
		${PKG_REPO_DEFAULT} \
1148
		${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo.conf \
1149
		${TARGET} \
1150
		${TARGET_ARCH} \
1151
		${PKG_REPO_CONF_BRANCH}
1152

    
1153
	mtree \
1154
		-c \
1155
		-k uid,gid,mode,size,flags,sha256digest \
1156
		-p ${STAGE_CHROOT_DIR} \
1157
		-X ${_exclude_files} \
1158
		> ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.mtree
1159
	tar \
1160
		-C ${STAGE_CHROOT_DIR} \
1161
		-cJf ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.txz \
1162
		-X ${_exclude_files} \
1163
		.
1164

    
1165
	local _share_repos_path="${SCRATCHDIR}/repo-tmp/${PRODUCT_SHARE_DIR}/pkg/repos"
1166
	rm -rf ${SCRATCHDIR}/repo-tmp >/dev/null 2>&1
1167
	mkdir -p ${_share_repos_path} >/dev/null 2>&1
1168

    
1169
	setup_pkg_repo \
1170
		${PKG_REPO_DEFAULT} \
1171
		${_share_repos_path}/${PRODUCT_NAME}-repo.conf \
1172
		${TARGET} \
1173
		${TARGET_ARCH} \
1174
		${PKG_REPO_CONF_BRANCH} \
1175
		${PKG_REPO_SERVER_RELEASE}
1176

    
1177
	cp -f ${PKG_REPO_DEFAULT%%.conf}.descr ${_share_repos_path}
1178

    
1179
	# Add additional repos
1180
	for _template in ${PKG_REPO_BASE}/${PRODUCT_NAME}-repo-*.conf; do
1181
		_template_filename=$(basename ${_template})
1182
		setup_pkg_repo \
1183
			${_template} \
1184
			${_share_repos_path}/${_template_filename} \
1185
			${TARGET} \
1186
			${TARGET_ARCH} \
1187
			${PKG_REPO_CONF_BRANCH} \
1188
			${PKG_REPO_SERVER_RELEASE}
1189
		cp -f ${_template%%.conf}.descr ${_share_repos_path}
1190
	done
1191

    
1192
	core_pkg_create repo "" ${CORE_PKG_VERSION} ${SCRATCHDIR}/repo-tmp
1193

    
1194
	core_pkg_create rc "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1195
	core_pkg_create base "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1196
	core_pkg_create base-nanobsd "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1197
	core_pkg_create default-config "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1198

    
1199
	local DEFAULTCONF=${STAGE_CHROOT_DIR}/conf.default/config.xml
1200

    
1201
	# Save current WAN and LAN if value
1202
	local _old_wan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/wan/if" ${DEFAULTCONF})
1203
	local _old_lan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/lan/if" ${DEFAULTCONF})
1204

    
1205
	# Change default interface names to match vmware driver
1206
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "vmx0" ${DEFAULTCONF}
1207
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "vmx1" ${DEFAULTCONF}
1208
	core_pkg_create default-config "vmware" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1209

    
1210
	# Restore default values to be used by serial package
1211
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "${_old_wan_if}" ${DEFAULTCONF}
1212
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "${_old_lan_if}" ${DEFAULTCONF}
1213

    
1214
	# Activate serial console in config.xml
1215
	xml ed -L -P -d "${XML_ROOTOBJ}/system/enableserial" ${DEFAULTCONF}
1216
	xml ed -P -s "${XML_ROOTOBJ}/system" -t elem -n "enableserial" \
1217
		${DEFAULTCONF} > ${DEFAULTCONF}.tmp
1218
	xml fo -t ${DEFAULTCONF}.tmp > ${DEFAULTCONF}
1219
	rm -f ${DEFAULTCONF}.tmp
1220

    
1221
	echo force > ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force
1222

    
1223
	core_pkg_create default-config-serial "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1224

    
1225
	rm -f ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force
1226
	rm -f ${STAGE_CHROOT_DIR}/cf/conf/config.xml
1227

    
1228
	# Make sure pkg is present
1229
	pkg_bootstrap ${STAGE_CHROOT_DIR}
1230

    
1231
	echo "Done!"
1232
}
1233

    
1234
create_final_staging_area() {
1235
	if [ -z "${FINAL_CHROOT_DIR}" ]; then
1236
		echo ">>> ERROR: FINAL_CHROOT_DIR is not set, cannot continue!" | tee -a ${LOGFILE}
1237
		print_error_pfS
1238
	fi
1239

    
1240
	if [ -d "${FINAL_CHROOT_DIR}" ]; then
1241
		echo -n ">>> Previous ${FINAL_CHROOT_DIR} detected cleaning up..." | tee -a ${LOGFILE}
1242
		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 1>/dev/null
1243
		rm -rf ${FINAL_CHROOT_DIR}/* 2>&1 1>/dev/null
1244
		echo "Done." | tee -a ${LOGFILE}
1245
	fi
1246

    
1247
	echo ">>> Preparing Final image staging area: $(LC_ALL=C date)" 2>&1 | tee -a ${LOGFILE}
1248
	echo ">>> Cloning ${STAGE_CHROOT_DIR} to ${FINAL_CHROOT_DIR}" 2>&1 | tee -a ${LOGFILE}
1249
	clone_directory_contents ${STAGE_CHROOT_DIR} ${FINAL_CHROOT_DIR}
1250

    
1251
	if [ ! -f $FINAL_CHROOT_DIR/sbin/init ]; then
1252
		echo ">>> ERROR: Something went wrong during cloning -- Please verify!" 2>&1 | tee -a ${LOGFILE}
1253
		print_error_pfS
1254
	fi
1255
}
1256

    
1257
customize_stagearea_for_image() {
1258
	local _image_type="$1"
1259
	local _default_config=""
1260

    
1261
	if [ -n "$2" ]; then
1262
		_default_config="$2"
1263
	elif [ "${_image_type}" = "nanobsd" -o \
1264
	     "${_image_type}" = "memstickserial" -o \
1265
	     "${_image_type}" = "memstickadi" ]; then
1266
		_default_config="default-config-serial"
1267
	elif [ "${_image_type}" = "ova" ]; then
1268
		_default_config="default-config-vmware"
1269
	else
1270
		_default_config="default-config"
1271
	fi
1272

    
1273
	# Prepare final stage area
1274
	create_final_staging_area
1275

    
1276
	pkg_chroot_add ${FINAL_CHROOT_DIR} rc
1277
	pkg_chroot_add ${FINAL_CHROOT_DIR} repo
1278

    
1279
	if [ "${_image_type}" = "nanobsd" -o \
1280
	     "${_image_type}" = "nanobsd-vga" ]; then
1281

    
1282
		mkdir -p ${FINAL_CHROOT_DIR}/root/var/db \
1283
			 ${FINAL_CHROOT_DIR}/root/var/cache \
1284
			 ${FINAL_CHROOT_DIR}/var/db/pkg \
1285
			 ${FINAL_CHROOT_DIR}/var/cache/pkg
1286
		mv -f ${FINAL_CHROOT_DIR}/var/db/pkg ${FINAL_CHROOT_DIR}/root/var/db
1287
		mv -f ${FINAL_CHROOT_DIR}/var/cache/pkg ${FINAL_CHROOT_DIR}/root/var/cache
1288
		ln -sf ../../root/var/db/pkg ${FINAL_CHROOT_DIR}/var/db/pkg
1289
		ln -sf ../../root/var/cache/pkg ${FINAL_CHROOT_DIR}/var/cache/pkg
1290

    
1291
		pkg_chroot_add ${FINAL_CHROOT_DIR} base-nanobsd
1292
	else
1293
		pkg_chroot_add ${FINAL_CHROOT_DIR} base
1294
	fi
1295

    
1296
	if [ "${_image_type}" = "iso" -o \
1297
	     "${_image_type}" = "memstick" -o \
1298
	     "${_image_type}" = "memstickserial" -o \
1299
	     "${_image_type}" = "memstickadi" ]; then
1300
		install_bsdinstaller
1301
		mkdir -p ${FINAL_CHROOT_DIR}/pkgs
1302
		cp ${CORE_PKG_REAL_PATH}/All/*default-config*.txz ${FINAL_CHROOT_DIR}/pkgs
1303
	fi
1304

    
1305
	pkg_chroot_add ${FINAL_CHROOT_DIR} ${_default_config}
1306

    
1307
	# XXX: Workaround to avoid pkg to complain regarding release
1308
	#      repo on first boot since packages are installed from
1309
	#      staging server during build phase
1310
	if [ "${PKG_REPO_SERVER}" != "${PKG_REPO_SERVER_RELEASE}" ]; then
1311
		_read_cmd="select value from repodata where key='packagesite'"
1312
		for _db in ${FINAL_CHROOT_DIR}/var/db/pkg/repo-*sqlite; do
1313
			_cur=$(/usr/local/bin/sqlite3 ${_db} "${_read_cmd}")
1314
			_new=$(echo "${_cur}" | sed -e "s,^${PKG_REPO_SERVER},${PKG_REPO_SERVER_RELEASE},")
1315
			/usr/local/bin/sqlite3 ${_db} "update repodata set value='${_new}' where key='packagesite'"
1316
		done
1317
	fi
1318
}
1319

    
1320
create_distribution_tarball() {
1321
	mkdir -p ${FINAL_CHROOT_DIR}/install
1322

    
1323
	tar -C ${FINAL_CHROOT_DIR} --exclude ./install --exclude ./pkgs -cJf ${FINAL_CHROOT_DIR}/install/${PRODUCT_NAME}.txz .
1324
}
1325

    
1326
create_iso_image() {
1327
	LOGFILE=${BUILDER_LOGS}/isoimage.${TARGET}
1328
	echo ">>> Building bootable ISO image for ${TARGET}" | tee -a ${LOGFILE}
1329
	if [ -z "${DEFAULT_KERNEL}" ]; then
1330
		echo ">>> ERROR: Could not identify DEFAULT_KERNEL to install on image!" | tee -a ${LOGFILE}
1331
		print_error_pfS
1332
	fi
1333

    
1334
	customize_stagearea_for_image "iso"
1335
	install_default_kernel ${DEFAULT_KERNEL}
1336

    
1337
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1338

    
1339
	FSLABEL=$(echo ${PRODUCT_NAME} | tr '[:lower:]' '[:upper:]')
1340
	echo "/dev/iso9660/${FSLABEL} / cd9660 ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
1341

    
1342
	# This check is for supporting create memstick/ova images
1343
	echo -n ">>> Running command: script -aq $LOGFILE makefs -t cd9660 -o bootimage=\"i386;${FINAL_CHROOT_DIR}/boot/cdboot \"-o no-emul-boot -o rockridge " | tee -a ${LOGFILE}
1344
	echo "-o label=${FSLABEL} -o publisher=\"${PRODUCT_NAME} project.\" $ISOPATH ${FINAL_CHROOT_DIR}" | tee -a ${LOGFILE}
1345

    
1346
	create_distribution_tarball
1347

    
1348
	# Remove /rescue from iso since cd9660 cannot deal with hardlinks
1349
	rm -rf ${FINAL_CHROOT_DIR}/rescue
1350

    
1351
	makefs -t cd9660 -o bootimage="i386;${FINAL_CHROOT_DIR}/boot/cdboot" -o no-emul-boot -o rockridge \
1352
		-o label=${FSLABEL} -o publisher="${PRODUCT_NAME} project." $ISOPATH ${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
1353
	if [ $? -ne 0 -o ! -f $ISOPATH ]; then
1354
		if [ -f ${ISOPATH} ]; then
1355
			rm -f $ISOPATH
1356
		fi
1357
		echo ">>> ERROR: Something wrong happened during ISO image creation. STOPPING!" | tee -a ${LOGFILE}
1358
		print_error_pfS
1359
	fi
1360
	gzip -qf $ISOPATH &
1361
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1362

    
1363
	echo ">>> ISO created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1364
}
1365

    
1366
create_memstick_image() {
1367

    
1368
	LOGFILE=${BUILDER_LOGS}/memstick.${TARGET}
1369
	if [ "${MEMSTICKPATH}" = "" ]; then
1370
		echo ">>> MEMSTICKPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1371
		return
1372
	fi
1373

    
1374
	customize_stagearea_for_image "memstick"
1375
	install_default_kernel ${DEFAULT_KERNEL}
1376

    
1377
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1378

    
1379
	echo ">>> Creating memstick to ${MEMSTICKPATH}." 2>&1 | tee -a ${LOGFILE}
1380
	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
1381
	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
1382

    
1383
	create_distribution_tarball
1384

    
1385
	makefs -B little -o label=${PRODUCT_NAME},version=2 ${MEMSTICKPATH} ${FINAL_CHROOT_DIR}
1386
	if [ $? -ne 0 ]; then
1387
		if [ -f ${MEMSTICKPATH} ]; then
1388
			rm -f $MEMSTICKPATH
1389
		fi
1390
		echo ">>> ERROR: Something wrong happened during MEMSTICK image creation. STOPPING!" | tee -a ${LOGFILE}
1391
		print_error_pfS
1392
	fi
1393
	MD=$(mdconfig -a -t vnode -f $MEMSTICKPATH)
1394
	# Just in case
1395
	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
1396
	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
1397
	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
1398
	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
1399
	trap "-" 1 2 15 EXIT
1400
	mdconfig -d -u ${MD} 2>&1 | tee -a ${LOGFILE}
1401
	gzip -qf $MEMSTICKPATH &
1402
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1403

    
1404
	echo ">>> MEMSTICK created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1405
}
1406

    
1407
create_memstick_serial_image() {
1408
	LOGFILE=${BUILDER_LOGS}/memstickserial.${TARGET}
1409
	if [ "${MEMSTICKSERIALPATH}" = "" ]; then
1410
		echo ">>> MEMSTICKSERIALPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1411
		return
1412
	fi
1413

    
1414
	customize_stagearea_for_image "memstickserial"
1415
	install_default_kernel ${DEFAULT_KERNEL}
1416

    
1417
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1418

    
1419
	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
1420
	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
1421

    
1422
	echo ">>> Creating serial memstick to ${MEMSTICKSERIALPATH}." 2>&1 | tee -a ${LOGFILE}
1423

    
1424
	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
1425
	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
1426

    
1427
	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
1428
	# Activate serial console in boot.config
1429
	if [ -f ${BOOTCONF} ]; then
1430
		sed -i "" '/-D$/d' ${BOOTCONF}
1431
	fi
1432
	echo "-S115200 -D" >> ${BOOTCONF}
1433

    
1434
	# Remove old console options if present.
1435
	[ -f "${LOADERCONF}" ] \
1436
		&& sed -i "" -Ee "/(console|boot_multicons|boot_serial)/d" ${LOADERCONF}
1437
	# Activate serial console+video console in loader.conf
1438
	echo 'boot_multicons="YES"' >>  ${LOADERCONF}
1439
	echo 'boot_serial="YES"' >> ${LOADERCONF}
1440
	echo 'console="comconsole,vidconsole"' >> ${LOADERCONF}
1441
	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
1442

    
1443
	create_distribution_tarball
1444

    
1445
	makefs -B little -o label=${PRODUCT_NAME},version=2 ${MEMSTICKSERIALPATH} ${FINAL_CHROOT_DIR}
1446
	if [ $? -ne 0 ]; then
1447
		if [ -f ${MEMSTICKSERIALPATH} ]; then
1448
			rm -f $MEMSTICKSERIALPATH
1449
		fi
1450
		echo ">>> ERROR: Something wrong happened during MEMSTICKSERIAL image creation. STOPPING!" | tee -a ${LOGFILE}
1451
		print_error_pfS
1452
	fi
1453
	MD=$(mdconfig -a -t vnode -f $MEMSTICKSERIALPATH)
1454
	# Just in case
1455
	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
1456
	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
1457
	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
1458
	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
1459
	trap "-" 1 2 15 EXIT
1460
	mdconfig -d -u ${MD} 2>&1 >> ${LOGFILE}
1461
	gzip -qf $MEMSTICKSERIALPATH &
1462
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1463

    
1464
	echo ">>> MEMSTICKSERIAL created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1465
}
1466

    
1467
create_memstick_adi_image() {
1468
	LOGFILE=${BUILDER_LOGS}/memstickadi.${TARGET}
1469
	if [ "${MEMSTICKADIPATH}" = "" ]; then
1470
		echo ">>> MEMSTICKADIPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1471
		return
1472
	fi
1473

    
1474
	customize_stagearea_for_image "memstickadi"
1475
	install_default_kernel ${DEFAULT_KERNEL}
1476

    
1477
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1478

    
1479
	echo "/dev/ufs/${PRODUCT_NAME} / ufs ro 0 0" > ${FINAL_CHROOT_DIR}/etc/fstab
1480
	echo "kern.cam.boot_delay=10000" >> ${FINAL_CHROOT_DIR}/boot/loader.conf.local
1481

    
1482
	echo ">>> Creating serial memstick to ${MEMSTICKADIPATH}." 2>&1 | tee -a ${LOGFILE}
1483

    
1484
	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
1485
	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
1486

    
1487
	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
1488
	# Activate serial console in boot.config
1489
	if [ -f ${BOOTCONF} ]; then
1490
		sed -i "" '/-[Dh]$/d' ${BOOTCONF}
1491
	fi
1492
	echo "-S115200 -h" >> ${BOOTCONF}
1493

    
1494
	# Remove old console options if present.
1495
	[ -f "${LOADERCONF}" ] \
1496
		&& sed -i "" -Ee "/(console|boot_multicons|boot_serial|hint.uart)/d" ${LOADERCONF}
1497
	# Activate serial console+video console in loader.conf
1498
	echo 'boot_serial="YES"' >> ${LOADERCONF}
1499
	echo 'console="comconsole"' >> ${LOADERCONF}
1500
	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
1501
	echo 'comconsole_port="0x2F8"' >> ${LOADERCONF}
1502
	echo 'hint.uart.0.flags="0x00"' >> ${LOADERCONF}
1503
	echo 'hint.uart.1.flags="0x10"' >> ${LOADERCONF}
1504

    
1505
	create_distribution_tarball
1506

    
1507
	makefs -B little -o label=${PRODUCT_NAME},version=2 ${MEMSTICKADIPATH} ${FINAL_CHROOT_DIR}
1508
	if [ $? -ne 0 ]; then
1509
		if [ -f ${MEMSTICKADIPATH} ]; then
1510
			rm -f $MEMSTICKADIPATH
1511
		fi
1512
		echo ">>> ERROR: Something wrong happened during MEMSTICKADI image creation. STOPPING!" | tee -a ${LOGFILE}
1513
		print_error_pfS
1514
	fi
1515
	MD=$(mdconfig -a -t vnode -f $MEMSTICKADIPATH)
1516
	# Just in case
1517
	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
1518
	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
1519
	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
1520
	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
1521
	trap "-" 1 2 15 EXIT
1522
	mdconfig -d -u ${MD} 2>&1 >> ${LOGFILE}
1523
	gzip -qf $MEMSTICKADIPATH &
1524
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1525

    
1526
	echo ">>> MEMSTICKADI created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1527
}
1528

    
1529
# Create pkg conf on desired place with desired arch/branch
1530
setup_pkg_repo() {
1531
	if [ -z "${5}" ]; then
1532
		return
1533
	fi
1534

    
1535
	local _template="${1}"
1536
	local _target="${2}"
1537
	local _arch="${3}"
1538
	local _target_arch="${4}"
1539
	local _branch="${5}"
1540
	local _pkg_repo_server="${6}"
1541

    
1542
	if [ -z "${_template}" -o ! -f "${_template}" ]; then
1543
		echo ">>> ERROR: It was not possible to find pkg conf template ${_template}"
1544
		print_error_pfS
1545
	fi
1546

    
1547
	if [ -z "${_pkg_repo_server}" ]; then
1548
		_pkg_repo_server=${PKG_REPO_SERVER}
1549
	fi
1550

    
1551
	mkdir -p $(dirname ${_target}) >/dev/null 2>&1
1552

    
1553
	sed \
1554
		-e "s/%%ARCH%%/${_target_arch}/" \
1555
		-e "s/%%GIT_REPO_BRANCH_OR_TAG%%/${_branch}/g" \
1556
		-e "s,%%PKG_REPO_SERVER%%,${_pkg_repo_server},g" \
1557
		-e "s/%%PRODUCT_NAME%%/${PRODUCT_NAME}/g" \
1558
		${_template} \
1559
		> ${_target}
1560
}
1561

    
1562
# This routine ensures any ports / binaries that the builder
1563
# system needs are on disk and ready for execution.
1564
builder_setup() {
1565
	# If Product-builder is already installed, just leave
1566
	if pkg info -e -q ${PRODUCT_NAME}-builder; then
1567
		return
1568
	fi
1569

    
1570
	if [ ! -f ${PKG_REPO_PATH} ]; then
1571
		[ -d $(dirname ${PKG_REPO_PATH}) ] \
1572
			|| mkdir -p $(dirname ${PKG_REPO_PATH})
1573

    
1574
		update_freebsd_sources
1575

    
1576
		local _arch=$(uname -m)
1577
		setup_pkg_repo \
1578
			${PKG_REPO_DEFAULT} \
1579
			${PKG_REPO_PATH} \
1580
			${_arch} \
1581
			${_arch} \
1582
			${PKG_REPO_CONF_BRANCH}
1583

    
1584
		# Use fingerprint keys from repo
1585
		sed -i '' -e "/fingerprints:/ s,\"/,\"${BUILDER_ROOT}/src/," \
1586
			${PKG_REPO_PATH}
1587
	fi
1588

    
1589
	pkg install ${PRODUCT_NAME}-builder
1590
}
1591

    
1592
# Updates FreeBSD sources
1593
update_freebsd_sources() {
1594
	if [ "${1}" = "full" ]; then
1595
		local _full=1
1596
		local _clone_params=""
1597
	else
1598
		local _full=0
1599
		local _clone_params="--depth 1 --single-branch"
1600
	fi
1601

    
1602
	if [ ! -d "${FREEBSD_SRC_DIR}" ]; then
1603
		mkdir -p ${FREEBSD_SRC_DIR}
1604
	fi
1605

    
1606
	if [ -n "${NO_BUILDWORLD}" -a -n "${NO_BUILDKERNEL}" ]; then
1607
		echo ">>> NO_BUILDWORLD and NO_BUILDKERNEL set, skipping update of freebsd sources" | tee -a ${LOGFILE}
1608
		return
1609
	fi
1610

    
1611
	echo -n ">>> Obtaining FreeBSD sources ${FREEBSD_BRANCH}..."
1612
	local _FREEBSD_BRANCH=${FREEBSD_BRANCH:-"devel"}
1613
	local _CLONE=1
1614

    
1615
	if [ -d "${FREEBSD_SRC_DIR}/.git" ]; then
1616
		CUR_BRANCH=$(cd ${FREEBSD_SRC_DIR} && git branch | grep '^\*' | cut -d' ' -f2)
1617
		if [ ${_full} -eq 0 -a "${CUR_BRANCH}" = "${_FREEBSD_BRANCH}" ]; then
1618
			_CLONE=0
1619
			( cd ${FREEBSD_SRC_DIR} && git clean -fd; git fetch origin; git reset --hard origin/${_FREEBSD_BRANCH} ) 2>&1 | grep -C3 -i -E 'error|fatal'
1620
		else
1621
			rm -rf ${FREEBSD_SRC_DIR}
1622
		fi
1623
	fi
1624

    
1625
	if [ ${_CLONE} -eq 1 ]; then
1626
		( git clone --branch ${_FREEBSD_BRANCH} ${_clone_params} ${FREEBSD_REPO_BASE} ${FREEBSD_SRC_DIR} ) 2>&1 | grep -C3 -i -E 'error|fatal'
1627
	fi
1628

    
1629
	if [ ! -d "${FREEBSD_SRC_DIR}/.git" ]; then
1630
		echo ">>> ERROR: It was not possible to clone FreeBSD src repo"
1631
		print_error_pfS
1632
	fi
1633

    
1634
	if [ -n "${GIT_FREEBSD_COSHA1}" ]; then
1635
		( cd ${FREEBSD_SRC_DIR} && git checkout ${GIT_FREEBSD_COSHA1} ) 2>&1 | grep -C3 -i -E 'error|fatal'
1636
	fi
1637
	echo "Done!"
1638
}
1639

    
1640
pkg_chroot() {
1641
	local _root="${1}"
1642
	shift
1643

    
1644
	if [ $# -eq 0 ]; then
1645
		return -1
1646
	fi
1647

    
1648
	if [ -z "${_root}" -o "${_root}" = "/" -o ! -d "${_root}" ]; then
1649
		return -1
1650
	fi
1651

    
1652
	mkdir -p \
1653
		${SCRATCHDIR}/pkg_cache \
1654
		${_root}/var/cache/pkg \
1655
		${_root}/dev
1656

    
1657
	/sbin/mount -t nullfs ${SCRATCHDIR}/pkg_cache ${_root}/var/cache/pkg
1658
	/sbin/mount -t devfs devfs ${_root}/dev
1659
	cp -f /etc/resolv.conf ${_root}/etc/resolv.conf
1660
	touch ${BUILDER_LOGS}/install_pkg_install_ports.txt
1661
	script -aq ${BUILDER_LOGS}/install_pkg_install_ports.txt pkg -c ${_root} $@ >/dev/null 2>&1
1662
	rm -f ${_root}/etc/resolv.conf
1663
	/sbin/umount -f ${_root}/dev
1664
	/sbin/umount -f ${_root}/var/cache/pkg
1665
}
1666

    
1667

    
1668
pkg_chroot_add() {
1669
	if [ -z "${1}" -o -z "${2}" ]; then
1670
		return 1
1671
	fi
1672

    
1673
	local _target="${1}"
1674
	local _pkg="$(get_pkg_name ${2}).txz"
1675

    
1676
	if [ ! -d "${_target}" ]; then
1677
		echo ">>> ERROR: Target dir ${_target} not found"
1678
		print_error_pfS
1679
	fi
1680

    
1681
	if [ ! -f ${CORE_PKG_REAL_PATH}/All/${_pkg} ]; then
1682
		echo ">>> ERROR: Package ${_pkg} not found"
1683
		print_error_pfS
1684
	fi
1685

    
1686
	cp ${CORE_PKG_REAL_PATH}/All/${_pkg} ${_target}
1687
	pkg_chroot ${_target} add /${_pkg}
1688
	rm -f ${_target}/${_pkg}
1689
}
1690

    
1691
pkg_bootstrap() {
1692
	local _root=${1:-"${STAGE_CHROOT_DIR}"}
1693

    
1694
	setup_pkg_repo \
1695
		${PKG_REPO_DEFAULT} \
1696
		${_root}${PKG_REPO_PATH} \
1697
		${TARGET} \
1698
		${TARGET_ARCH} \
1699
		${PKG_REPO_CONF_BRANCH}
1700

    
1701
	pkg_chroot ${_root} bootstrap -f
1702
}
1703

    
1704
# This routine assists with installing various
1705
# freebsd ports files into the pfsense-fs staging
1706
# area.
1707
install_pkg_install_ports() {
1708
	local MAIN_PKG="${1}"
1709

    
1710
	if [ -z "${MAIN_PKG}" ]; then
1711
		MAIN_PKG=${PRODUCT_NAME}
1712
	fi
1713

    
1714
	echo ">>> Installing pkg repository in chroot (${STAGE_CHROOT_DIR})..."
1715

    
1716
	[ -d ${STAGE_CHROOT_DIR}/var/cache/pkg ] || \
1717
		mkdir -p ${STAGE_CHROOT_DIR}/var/cache/pkg
1718

    
1719
	[ -d ${SCRATCHDIR}/pkg_cache ] || \
1720
		mkdir -p ${SCRATCHDIR}/pkg_cache
1721

    
1722
	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (starting)"
1723
	# First mark all packages as automatically installed
1724
	pkg_chroot ${STAGE_CHROOT_DIR} set -A 1 -a
1725
	# Install all necessary packages
1726
	pkg_chroot ${STAGE_CHROOT_DIR} install ${MAIN_PKG} ${custom_package_list}
1727
	# Make sure required packages are set as non-automatic
1728
	pkg_chroot ${STAGE_CHROOT_DIR} set -A 0 pkg ${MAIN_PKG} ${custom_package_list}
1729
	# Remove unnecessary packages
1730
	pkg_chroot ${STAGE_CHROOT_DIR} autoremove
1731
	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (finshied)"
1732
}
1733

    
1734
install_bsdinstaller() {
1735
	local _params=""
1736

    
1737
	# Use staging repo on RELEASE
1738
	if [ -n "${_IS_RELEASE}" ]; then
1739
		mkdir -p ${FINAL_CHROOT_DIR}/tmp/pkg-repo
1740
		cp -f ${STAGE_CHROOT_DIR}${PKG_REPO_PATH} \
1741
			${FINAL_CHROOT_DIR}/tmp/pkg-repo
1742
		_params="--repo-conf-dir /tmp/pkg-repo "
1743
	fi
1744

    
1745
	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (starting)"
1746
	pkg_chroot ${FINAL_CHROOT_DIR} ${_params}install -f bsdinstaller
1747
	sed -i '' -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME}," \
1748
		  -e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION}," \
1749
		  -e "s,%%ARCH%%,${TARGET}," \
1750
		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense.lua \
1751
		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense_rescue.lua
1752
	if [ -n "${_IS_RELEASE}" ]; then
1753
		rm -rf ${FINAL_CHROOT_DIR}/tmp/pkg-repo
1754
	fi
1755
	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (finished)"
1756
}
1757

    
1758
staginareas_clean_each_run() {
1759
	echo -n ">>> Cleaning build directories: "
1760
	if [ -d "${FINAL_CHROOT_DIR}" ]; then
1761
		BASENAME=$(basename ${FINAL_CHROOT_DIR})
1762
		echo -n "$BASENAME "
1763
		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 >/dev/null
1764
		rm -rf ${FINAL_CHROOT_DIR}/* 2>/dev/null
1765
	fi
1766
	echo "Done!"
1767
}
1768

    
1769
# Imported from FreeSBIE
1770
buildkernel() {
1771
	if [ -n "${NO_BUILDKERNEL}" ]; then
1772
		echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}
1773
		return
1774
	fi
1775

    
1776
	if [ -z "${KERNCONF}" ]; then
1777
		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
1778
		print_error_pfS
1779
	fi
1780

    
1781
	if [ -n "${KERNELCONF}" ]; then
1782
		export KERNCONFDIR=$(dirname ${KERNELCONF})
1783
		export KERNCONF=$(basename ${KERNELCONF})
1784
	fi
1785

    
1786
	SRCCONFBASENAME=$(basename ${SRC_CONF})
1787
	echo ">>> KERNCONFDIR: ${KERNCONFDIR}"
1788
	echo ">>> ARCH:        ${TARGET}"
1789
	echo ">>> SRC_CONF:    ${SRCCONFBASENAME}"
1790

    
1791
	makeargs="${MAKEJ_KERNEL} SRCCONF=${SRC_CONF} __MAKE_CONF=${MAKE_CONF} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET}"
1792
	echo ">>> Builder is running the command: script -aq $LOGFILE make -DNO_KERNELCLEAN $makeargs buildkernel KERNCONF=${KERNCONF}" | tee -a $LOGFILE
1793
	(script -q $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_KERNELCLEAN $makeargs buildkernel KERNCONF=${KERNCONF} || print_error_pfS;) | egrep '^>>>'
1794
}
1795

    
1796
# Imported from FreeSBIE
1797
installkernel() {
1798
	if [ -z "${KERNCONF}" ]; then
1799
		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
1800
		print_error_pfS
1801
	fi
1802

    
1803
	if [ -n "${KERNELCONF}" ]; then
1804
		export KERNCONFDIR=$(dirname ${KERNELCONF})
1805
		export KERNCONF=$(basename ${KERNELCONF})
1806
	fi
1807

    
1808
	mkdir -p ${STAGE_CHROOT_DIR}/boot
1809
	makeargs="${MAKEJ_KERNEL} SRCCONF=${SRC_CONF} __MAKE_CONF=${MAKE_CONF} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET} DESTDIR=${KERNEL_DESTDIR}"
1810
	echo ">>> Builder is running the command: script -aq $LOGFILE make ${makeargs} installkernel KERNCONF=${KERNCONF}"  | tee -a $LOGFILE
1811
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installkernel KERNCONF=${KERNCONF} || print_error_pfS;) | egrep '^>>>'
1812
	gzip -f9 $KERNEL_DESTDIR/boot/kernel/kernel
1813
}
1814

    
1815
# Launch is ran first to setup a few variables that we need
1816
# Imported from FreeSBIE
1817
launch() {
1818
	if [ "$(id -u)" != "0" ]; then
1819
		echo "Sorry, this must be done as root."
1820
	fi
1821

    
1822
	echo ">>> Operation $0 has started at $(date)"
1823
}
1824

    
1825
finish() {
1826
	echo ">>> Operation $0 has ended at $(date)"
1827
}
1828

    
1829
pkg_repo_rsync() {
1830
	local _repo_path="${1}"
1831

    
1832
	if [ -z "${_repo_path}" -o ! -d "${_repo_path}" ]; then
1833
		return
1834
	fi
1835

    
1836
	if [ -z "${LOGFILE}" ]; then
1837
		local _logfile="/dev/null"
1838
	else
1839
		local _logfile="${LOGFILE}"
1840
	fi
1841

    
1842
	if [ -n "${PKG_REPO_SIGNING_COMMAND}" ]; then
1843

    
1844
		# Detect poudriere directory structure
1845
		if [ -L "${_repo_path}/.latest" ]; then
1846
			local _real_repo_path=$(readlink -f ${_repo_path}/.latest)
1847
		else
1848
			local _real_repo_path=${_repo_path}
1849
		fi
1850

    
1851
		echo -n ">>> Signing repository... " | tee -a ${_logfile}
1852
		############ ATTENTION ##############
1853
		#
1854
		# For some reason pkg-repo fail without / in the end of directory name
1855
		# so removing it will break command
1856
		#
1857
		# https://github.com/freebsd/pkg/issues/1364
1858
		#
1859
		if script -aq ${_logfile} pkg repo ${_real_repo_path}/ \
1860
		    signing_command: ${PKG_REPO_SIGNING_COMMAND} >/dev/null 2>&1; then
1861
			echo "Done!" | tee -a ${_logfile}
1862
		else
1863
			echo "Failed!" | tee -a ${_logfile}
1864
			echo ">>> ERROR: An error occurred trying to sign repo"
1865
			print_error_pfS
1866
		fi
1867

    
1868
		local _pkgfile="${_repo_path}/Latest/pkg.txz"
1869
		if [ -e ${_pkgfile} ]; then
1870
			echo -n ">>> Signing Latest/pkg.txz for bootstraping... " | tee -a ${_logfile}
1871

    
1872
			if sha256 -q ${_pkgfile} | ${PKG_REPO_SIGNING_COMMAND} \
1873
			    > ${_pkgfile}.sig 2>/dev/null; then
1874
				echo "Done!" | tee -a ${_logfile}
1875
			else
1876
				echo "Failed!" | tee -a ${_logfile}
1877
				echo ">>> ERROR: An error occurred trying to sign Latest/pkg.txz"
1878
				print_error_pfS
1879
			fi
1880
		fi
1881
	fi
1882

    
1883
	if [ -n "${DO_NOT_UPLOAD}" ]; then
1884
		return
1885
	fi
1886

    
1887
	echo -n ">>> Sending updated repository to ${PKG_RSYNC_HOSTNAME}... " | tee -a ${_logfile}
1888
	if script -aq ${_logfile} rsync -ave "ssh -p ${PKG_RSYNC_SSH_PORT}" \
1889
		--timeout=60 --delete-delay ${_repo_path} \
1890
		${PKG_RSYNC_USERNAME}@${PKG_RSYNC_HOSTNAME}:${PKG_RSYNC_DESTDIR} >/dev/null 2>&1
1891
	then
1892
		echo "Done!" | tee -a ${_logfile}
1893
	else
1894
		echo "Failed!" | tee -a ${_logfile}
1895
		echo ">>> ERROR: An error occurred sending repo to remote hostname"
1896
		print_error_pfS
1897
	fi
1898
}
1899

    
1900
poudriere_create_patch() {
1901
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${POUDRIERE_BRANCH}.patch"
1902

    
1903
	if [ -z "${FREEBSD_PARENT_BRANCH}" ]; then
1904
		echo ">>> ERROR: FREEBSD_PARENT_BRANCH is not set"
1905
	fi
1906

    
1907
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1908

    
1909
	# Get FreeBSD source and apply patches
1910
	update_freebsd_sources full
1911

    
1912
	[ -f "${_jail_patch}" ] && \
1913
		rm -f "${_jail_patch}"
1914

    
1915
	# Create a big patch with all our changes to use on jail
1916
	( \
1917
		cd ${FREEBSD_SRC_DIR} && \
1918
		git diff $(git merge-base origin/${FREEBSD_PARENT_BRANCH} ${FREEBSD_BRANCH}) > ${_jail_patch}
1919
	) >/dev/null 2>&1
1920

    
1921
	# Check if patch was created
1922
	if [ ! -s "${_jail_patch}" ]; then
1923
		echo ">>> ERROR: Patch does not exist or is empty, aborting..." | tee -a ${LOGFILE}
1924
		print_error_pfS
1925
	fi
1926
}
1927

    
1928
poudriere_possible_archs() {
1929
	local _arch=$(uname -m)
1930
	local _archs="i386.i386"
1931

    
1932
	# If host is amd64, we'll create both repos, and if possible armv6
1933
	if [ "${_arch}" = "amd64" ]; then
1934
		_archs="amd64.amd64 ${_archs}"
1935

    
1936
		if [ -f /usr/local/bin/qemu-arm-static ]; then
1937
			# Make sure binmiscctl is ok
1938
			/usr/local/etc/rc.d/qemu_user_static forcestart >/dev/null 2>&1
1939

    
1940
			if binmiscctl lookup armv6 >/dev/null 2>&1; then
1941
				_archs="${_archs} arm.armv6"
1942
			fi
1943
		fi
1944
	fi
1945

    
1946
	if [ -n "${ARCH_LIST}" ]; then
1947
		local _found=0
1948
		for _desired_arch in ${ARCH_LIST}; do
1949
			_found=0
1950
			for _possible_arch in ${_archs}; do
1951
				if [ "${_desired_arch}" = "${_possible_arch}" ]; then
1952
					_found=1
1953
					break
1954
				fi
1955
			done
1956
			if [ ${_found} -eq 0 ]; then
1957
				echo ">>> ERROR: Impossible to build for arch: ${_desired_arch}"
1958
				print_error_pfS
1959
			fi
1960
		done
1961
		_archs="${ARCH_LIST}"
1962
	fi
1963

    
1964
	echo ${_archs}
1965
}
1966

    
1967
poudriere_jail_name() {
1968
	local _jail_arch="${1}"
1969

    
1970
	if [ -z "${_jail_arch}" ]; then
1971
		return 1
1972
	fi
1973

    
1974
	# Remove arch
1975
	echo "${PRODUCT_NAME}_${POUDRIERE_BRANCH}_${_jail_arch##*.}"
1976
}
1977

    
1978
poudriere_rename_ports() {
1979
	if [ "${PRODUCT_NAME}" = "pfSense" ]; then
1980
		return;
1981
	fi
1982

    
1983
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1984

    
1985
	local _ports_dir="/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}"
1986

    
1987
	echo -n ">>> Renaming product ports on ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
1988
	for d in $(find ${_ports_dir} -depth 2 -type d -name '*pfSense*'); do
1989
		local _pdir=$(dirname ${d})
1990
		local _pname=$(echo $(basename ${d}) | sed "s,pfSense,${PRODUCT_NAME},")
1991
		local _plist=""
1992

    
1993
		if [ -e ${_pdir}/${_pname} ]; then
1994
			rm -rf ${_pdir}/${_pname}
1995
		fi
1996

    
1997
		cp -r ${d} ${_pdir}/${_pname}
1998

    
1999
		if [ -f ${_pdir}/${_pname}/pkg-plist ]; then
2000
			_plist=${_pdir}/${_pname}/pkg-plist
2001
		fi
2002

    
2003
		sed -i '' -e "s,pfSense,${PRODUCT_NAME},g" \
2004
			  -e "s,https://www.pfsense.org,${PRODUCT_URL},g" \
2005
			  -e "/^MAINTAINER=/ s,^.*$,MAINTAINER=	${PRODUCT_EMAIL}," \
2006
			${_pdir}/${_pname}/Makefile \
2007
			${_pdir}/${_pname}/pkg-descr ${_plist}
2008

    
2009
		# PHP module is special
2010
		if echo "${_pname}" | grep -q "^php[0-9]*-${PRODUCT_NAME}-module"; then
2011
			local _product_capital=$(echo ${PRODUCT_NAME} | tr '[a-z]' '[A-Z]')
2012
			sed -i '' -e "s,PHP_PFSENSE,PHP_${_product_capital},g" \
2013
				  -e "s,PFSENSE_SHARED_LIBADD,${_product_capital}_SHARED_LIBADD,g" \
2014
				  -e "s,pfSense,${PRODUCT_NAME},g" \
2015
				  -e "s,${PRODUCT_NAME}\.c,pfSense.c,g" \
2016
				${_pdir}/${_pname}/files/config.m4
2017

    
2018
			sed -i '' -e "s,COMPILE_DL_PFSENSE,COMPILE_DL_${_product_capital}," \
2019
				  -e "s,pfSense_module_entry,${PRODUCT_NAME}_module_entry,g" \
2020
				  -e "/ZEND_GET_MODULE/ s,pfSense,${PRODUCT_NAME}," \
2021
				  -e "/PHP_PFSENSE_WORLD_EXTNAME/ s,pfSense,${PRODUCT_NAME}," \
2022
				${_pdir}/${_pname}/files/pfSense.c \
2023
				${_pdir}/${_pname}/files/php_pfSense.h
2024
		fi
2025

    
2026
		if [ -d ${_pdir}/${_pname}/files ]; then
2027
			for fd in $(find ${_pdir}/${_pname}/files -type d -name '*pfSense*'); do
2028
				local _fddir=$(dirname ${fd})
2029
				local _fdname=$(echo $(basename ${fd}) | sed "s,pfSense,${PRODUCT_NAME},")
2030

    
2031
				mv ${fd} ${_fddir}/${_fdname}
2032
			done
2033
		fi
2034
	done
2035
	echo "Done!" | tee -a ${LOGFILE}
2036
}
2037

    
2038
poudriere_create_ports_tree() {
2039
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2040

    
2041
	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
2042
		local _branch=""
2043
		if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
2044
			echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
2045
			print_error_pfS
2046
		fi
2047
		if [ -n "${POUDRIERE_PORTS_GIT_BRANCH}" ]; then
2048
			_branch="-B ${POUDRIERE_PORTS_GIT_BRANCH}"
2049
		fi
2050
		echo -n ">>> Creating poudriere ports tree, it may take some time... " | tee -a ${LOGFILE}
2051
		if ! script -aq ${LOGFILE} poudriere ports -c -p "${POUDRIERE_PORTS_NAME}" -m git ${_branch} >/dev/null 2>&1; then
2052
			echo "" | tee -a ${LOGFILE}
2053
			echo ">>> ERROR: Error creating poudriere ports tree, aborting..." | tee -a ${LOGFILE}
2054
			print_error_pfS
2055
		fi
2056
		echo "Done!" | tee -a ${LOGFILE}
2057
		poudriere_rename_ports
2058
	fi
2059
}
2060

    
2061
poudriere_init() {
2062
	local _error=0
2063
	local _archs=$(poudriere_possible_archs)
2064
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${POUDRIERE_BRANCH}.patch"
2065

    
2066
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2067

    
2068
	# Sanity checks
2069
	if [ -z "${ZFS_TANK}" ]; then
2070
		echo ">>> ERROR: \$ZFS_TANK is empty" | tee -a ${LOGFILE}
2071
		error=1
2072
	fi
2073

    
2074
	if [ -z "${ZFS_ROOT}" ]; then
2075
		echo ">>> ERROR: \$ZFS_ROOT is empty" | tee -a ${LOGFILE}
2076
		error=1
2077
	fi
2078

    
2079
	if [ -z "${POUDRIERE_PORTS_NAME}" ]; then
2080
		echo ">>> ERROR: \$POUDRIERE_PORTS_NAME is empty" | tee -a ${LOGFILE}
2081
		error=1
2082
	fi
2083

    
2084
	if [ ${_error} -eq 1 ]; then
2085
		print_error_pfS
2086
	fi
2087

    
2088
	# Check if zpool exists
2089
	if ! zpool list ${ZFS_TANK} >/dev/null 2>&1; then
2090
		echo ">>> ERROR: ZFS tank ${ZFS_TANK} not found, please create it and try again..." | tee -a ${LOGFILE}
2091
		print_error_pfS
2092
	fi
2093

    
2094
	# Check if zfs rootfs exists
2095
	if ! zfs list ${ZFS_TANK}${ZFS_ROOT} >/dev/null 2>&1; then
2096
		echo -n ">>> Creating ZFS filesystem ${ZFS_TANK}${ZFS_ROOT}... "
2097
		if zfs create -o atime=off -o mountpoint=/usr/local${ZFS_ROOT} \
2098
		    ${ZFS_TANK}${ZFS_ROOT} >/dev/null 2>&1; then
2099
			echo "Done!"
2100
		else
2101
			echo "Failed!"
2102
			print_error_pfS
2103
		fi
2104
	fi
2105

    
2106
	# Make sure poudriere is installed
2107
	if ! pkg info --quiet poudriere; then
2108
		echo ">>> Installing poudriere..." | tee -a ${LOGFILE}
2109
		if ! pkg install poudriere >/dev/null 2>&1; then
2110
			echo ">>> ERROR: poudriere was not installed, aborting..." | tee -a ${LOGFILE}
2111
			print_error_pfS
2112
		fi
2113
	fi
2114

    
2115
	# Create poudriere.conf
2116
	if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
2117
		echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
2118
		print_error_pfS
2119
	fi
2120
	echo ">>> Creating poudriere.conf" | tee -a ${LOGFILE}
2121
	cat <<EOF >/usr/local/etc/poudriere.conf
2122
ZPOOL=${ZFS_TANK}
2123
ZROOTFS=${ZFS_ROOT}
2124
RESOLV_CONF=/etc/resolv.conf
2125
BASEFS=/usr/local/poudriere
2126
USE_PORTLINT=no
2127
USE_TMPFS=yes
2128
NOLINUX=yes
2129
DISTFILES_CACHE=/usr/ports/distfiles
2130
CHECK_CHANGED_OPTIONS=yes
2131
CHECK_CHANGED_DEPS=yes
2132
ATOMIC_PACKAGE_REPOSITORY=yes
2133
COMMIT_PACKAGES_ON_FAILURE=no
2134
EOF
2135

    
2136
	# Create specific items conf
2137
	[ ! -d /usr/local/etc/poudriere.d ] \
2138
		&& mkdir -p /usr/local/etc/poudriere.d
2139

    
2140
	cat <<EOF >/usr/local/etc/poudriere.d/${POUDRIERE_PORTS_NAME}-poudriere.conf
2141
GIT_URL="${POUDRIERE_PORTS_GIT_URL}"
2142
EOF
2143

    
2144
	# Create DISTFILES_CACHE if it doesn't exist
2145
	if [ ! -d /usr/ports/distfiles ]; then
2146
		mkdir -p /usr/ports/distfiles
2147
	fi
2148

    
2149
	# Remove old jails
2150
	for jail_arch in ${_archs}; do
2151
		jail_name=$(poudriere_jail_name ${jail_arch})
2152

    
2153
		if poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2154
			echo ">>> Poudriere jail ${jail_name} already exists, deleting it..." | tee -a ${LOGFILE}
2155
			poudriere jail -d -j "${jail_name}" >/dev/null 2>&1
2156
		fi
2157
	done
2158

    
2159
	# Remove old ports tree
2160
	if poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
2161
		echo ">>> Poudriere ports tree ${POUDRIERE_PORTS_NAME} already exists, deleting it..." | tee -a ${LOGFILE}
2162
		poudriere ports -d -p "${POUDRIERE_PORTS_NAME}"
2163
	fi
2164

    
2165
	poudriere_create_patch
2166

    
2167
	local native_xtools=""
2168
	# Now we are ready to create jails
2169
	for jail_arch in ${_archs}; do
2170
		jail_name=$(poudriere_jail_name ${jail_arch})
2171

    
2172
		if [ "${jail_arch}" = "arm.armv6" ]; then
2173
			native_xtools="-x"
2174
		else
2175
			native_xtools=""
2176
		fi
2177

    
2178
		echo -n ">>> Creating jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
2179
		# XXX: Change -m to git when it's available in poudriere
2180
		if ! script -aq ${LOGFILE} poudriere jail -c -j "${jail_name}" -v ${FREEBSD_PARENT_BRANCH} \
2181
				-a ${jail_arch} -m svn -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
2182
			echo "" | tee -a ${LOGFILE}
2183
			echo ">>> ERROR: Error creating jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
2184
			print_error_pfS
2185
		fi
2186
		echo "Done!" | tee -a ${LOGFILE}
2187
	done
2188

    
2189
	poudriere_create_ports_tree
2190

    
2191
	echo ">>> Poudriere is now configured!" | tee -a ${LOGFILE}
2192
}
2193

    
2194
poudriere_update_jails() {
2195
	local _archs=$(poudriere_possible_archs)
2196
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${POUDRIERE_BRANCH}.patch"
2197

    
2198
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2199

    
2200
	poudriere_create_patch
2201

    
2202
	local native_xtools=""
2203
	for jail_arch in ${_archs}; do
2204
		jail_name=$(poudriere_jail_name ${jail_arch})
2205

    
2206
		local _create_or_update="-u"
2207
		local _create_or_update_text="Updating"
2208
		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2209
			echo ">>> Poudriere jail ${jail_name} not found, creating..." | tee -a ${LOGFILE}
2210
			_create_or_update="-c -v ${FREEBSD_PARENT_BRANCH} -a ${jail_arch} -m svn"
2211
			_create_or_update_text="Creating"
2212
		fi
2213

    
2214
		if [ "${jail_arch}" = "arm.armv6" ]; then
2215
			native_xtools="-x"
2216
		else
2217
			native_xtools=""
2218
		fi
2219

    
2220
		echo -n ">>> ${_create_or_update_text} jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
2221
		if ! script -aq ${LOGFILE} poudriere jail ${_create_or_update} -j "${jail_name}" -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
2222
			echo "" | tee -a ${LOGFILE}
2223
			echo ">>> ERROR: Error ${_create_or_update_text} jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
2224
			print_error_pfS
2225
		fi
2226
		echo "Done!" | tee -a ${LOGFILE}
2227
	done
2228
}
2229

    
2230
poudriere_update_ports() {
2231
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2232

    
2233
	# Create ports tree if necessary
2234
	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
2235
		poudriere_create_ports_tree
2236
	else
2237
		echo -n ">>> Resetting local changes on ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
2238
		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" reset --hard >/dev/null 2>&1
2239
		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" clean -fd >/dev/null 2>&1
2240
		echo "Done!" | tee -a ${LOGFILE}
2241
		echo -n ">>> Updating ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
2242
		script -aq ${LOGFILE} poudriere ports -u -p "${POUDRIERE_PORTS_NAME}" >/dev/null 2>&1
2243
		echo "Done!" | tee -a ${LOGFILE}
2244
		poudriere_rename_ports
2245
	fi
2246
}
2247

    
2248
poudriere_bulk() {
2249
	local _archs=$(poudriere_possible_archs)
2250

    
2251
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2252

    
2253
	if [ -z "${DO_NOT_UPLOAD}" -a -z "${PKG_RSYNC_HOSTNAME}" ]; then
2254
		echo ">>> ERROR: PKG_RSYNC_HOSTNAME is not set"
2255
		print_error_pfS
2256
	fi
2257

    
2258
	poudriere_create_ports_tree
2259

    
2260
	[ -d /usr/local/etc/poudriere.d ] || \
2261
		mkdir -p /usr/local/etc/poudriere.d
2262

    
2263
	if [ -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" ]; then
2264
		cp -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" /usr/local/etc/poudriere.d/${POUDRIERE_PORTS_NAME}-make.conf
2265
	fi
2266

    
2267
	# Change version of pfSense meta ports for snapshots
2268
	if [ -z "${_IS_RELEASE}" ]; then
2269
		local _meta_pkg_version="$(echo "${PRODUCT_VERSION}" | sed 's,DEVELOPMENT,ALPHA,')-${DATESTRING}"
2270
		sed -i '' -e "/^DISTVERSION/ s,^.*,DISTVERSION=	${_meta_pkg_version}," \
2271
			/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}/security/${PRODUCT_NAME}/Makefile
2272
	fi
2273

    
2274
	for jail_arch in ${_archs}; do
2275
		jail_name=$(poudriere_jail_name ${jail_arch})
2276

    
2277
		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2278
			echo ">>> Poudriere jail ${jail_name} not found, skipping..." | tee -a ${LOGFILE}
2279
			continue
2280
		fi
2281

    
2282
		if [ -f "${POUDRIERE_BULK}.${jail_arch}" ]; then
2283
			_ref_bulk="${POUDRIERE_BULK}.${jail_arch}"
2284
		else
2285
			_ref_bulk="${POUDRIERE_BULK}"
2286
		fi
2287

    
2288
		_bulk=${SCRATCHDIR}/poudriere_bulk.${POUDRIERE_BRANCH}
2289
		sed -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" ${_ref_bulk} > ${_bulk}
2290

    
2291
		if ! poudriere bulk -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME}; then
2292
			echo ">>> ERROR: Something went wrong..."
2293
			print_error_pfS
2294
		fi
2295

    
2296
		echo ">>> Cleaning up old packages from repo..."
2297
		if ! poudriere pkgclean -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME} -y; then
2298
			echo ">>> ERROR: Something went wrong..."
2299
			print_error_pfS
2300
		fi
2301

    
2302
		# ./ is intentional, it's an rsync trick to make it chdir to directory before sending it
2303
		pkg_repo_rsync "/usr/local/poudriere/data/packages/./${jail_name}-${POUDRIERE_PORTS_NAME}"
2304
	done
2305
}
2306

    
2307
# This routine is called to write out to stdout
2308
# a string. The string is appended to $SNAPSHOTSLOGFILE
2309
# and we scp the log file to the builder host if
2310
# needed for the real time logging functions.
2311
snapshots_update_status() {
2312
	if [ -z "$1" ]; then
2313
		return
2314
	fi
2315
	if [ -z "${SNAPSHOTS}" -a -z "${POUDRIERE_SNAPSHOTS}" ]; then
2316
		return
2317
	fi
2318
	echo "$*"
2319
	echo "`date` -|- $*" >> $SNAPSHOTSLOGFILE
2320
	if [ -z "${DO_NOT_UPLOAD}" -a -n "${SNAPSHOTS_RSYNCIP}" ]; then
2321
		LU=$(cat $SNAPSHOTSLASTUPDATE 2>/dev/null)
2322
		CT=$(date "+%H%M%S")
2323
		# Only update every minute
2324
		if [ "$LU" != "$CT" ]; then
2325
			ssh ${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP} \
2326
				"mkdir -p ${SNAPSHOTS_RSYNCLOGS}"
2327
			scp -q $SNAPSHOTSLOGFILE \
2328
				${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP}:${SNAPSHOTS_RSYNCLOGS}/build.log
2329
			date "+%H%M%S" > $SNAPSHOTSLASTUPDATE
2330
		fi
2331
	fi
2332
}
2333

    
2334
# Copy the current log file to $filename.old on
2335
# the snapshot www server (real time logs)
2336
snapshots_rotate_logfile() {
2337
	if [ -z "${DO_NOT_UPLOAD}" -a -n "${SNAPSHOTS_RSYNCIP}" ]; then
2338
		scp -q $SNAPSHOTSLOGFILE \
2339
			${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP}:${SNAPSHOTS_RSYNCLOGS}/build.log.old
2340
	fi
2341

    
2342
	# Cleanup log file
2343
	rm -f $SNAPSHOTSLOGFILE;    touch $SNAPSHOTSLOGFILE
2344
	rm -f $SNAPSHOTSLASTUPDATE; touch $SNAPSHOTSLASTUPDATE
2345

    
2346
}
2347

    
2348
create_sha256() {
2349
	local _file="${1}"
2350

    
2351
	if [ ! -f "${_file}" ]; then
2352
		return 1
2353
	fi
2354

    
2355
	( \
2356
		cd $(dirname ${_file}) && \
2357
		sha256 $(basename ${_file}) > $(basename ${_file}).sha256 \
2358
	)
2359
}
2360

    
2361
snapshots_create_latest_symlink() {
2362
	local _image="${1}"
2363

    
2364
	if [ -z "${_image}" ]; then
2365
		return
2366
	fi
2367

    
2368
	if [ -z "${TIMESTAMP_SUFFIX}" ]; then
2369
		return
2370
	fi
2371

    
2372
	if [ ! -f "${_image}" ]; then
2373
		return
2374
	fi
2375

    
2376
	local _symlink=$(echo ${_image} | sed "s,${TIMESTAMP_SUFFIX},-latest,")
2377
	ln -sf $(basename ${_image}) ${_symlink}
2378
	ln -sf $(basename ${_image}).sha256 ${_symlink}.sha256
2379
}
2380

    
2381
snapshots_copy_to_staging_nanobsd() {
2382
	for NANOTYPE in nanobsd nanobsd-vga; do
2383
		for FILESIZE in ${1}; do
2384
			FILENAMEFULL="$(nanobsd_image_filename ${FILESIZE} ${NANOTYPE}).gz"
2385
			FILENAMEUPGRADE="$(nanobsd_image_filename ${FILESIZE} ${NANOTYPE} 1).gz"
2386
			mkdir -p $STAGINGAREA/nanobsd
2387
			mkdir -p $STAGINGAREA/nanobsdupdates
2388

    
2389
			cp -l $IMAGES_FINAL_DIR/$FILENAMEFULL $STAGINGAREA/nanobsd/ 2>/dev/null
2390
			cp -l $IMAGES_FINAL_DIR/$FILENAMEUPGRADE $STAGINGAREA/nanobsdupdates 2>/dev/null
2391

    
2392
			if [ -f $STAGINGAREA/nanobsd/$FILENAMEFULL ]; then
2393
				create_sha256 $STAGINGAREA/nanobsd/$FILENAMEFULL
2394
			fi
2395
			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
2396
				create_sha256 $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE
2397
			fi
2398

    
2399
			# Copy NanoBSD auto update:
2400
			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
2401
				cp -l $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz 2>/dev/null
2402
				create_sha256 $STAGINGAREAA/latest-${NANOTYPE}-$FILESIZE.img.gz
2403
				# NOTE: Updates need a file with output similar to date output
2404
				# Use the file generated at start of snapshots_dobuilds() to be consistent on times
2405
				cp $BUILTDATESTRINGFILE $STAGINGAREA/version-${NANOTYPE}-$FILESIZE
2406
			fi
2407
		done
2408
	done
2409
}
2410

    
2411
snapshots_copy_to_staging_iso_updates() {
2412
	local _img=""
2413

    
2414
	for _img in ${ISOPATH} ${MEMSTICKPATH} ${MEMSTICKSERIALPATH} ${MEMSTICKADIPATH}; do
2415
		if [ ! -f "${_img}.gz" ]; then
2416
			continue
2417
		fi
2418
		_img="${_img}.gz"
2419
		create_sha256 ${_img}
2420
		cp -l ${_img}* $STAGINGAREA/ 2>/dev/null
2421
		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${_img})
2422
	done
2423

    
2424
	if [ -f "${UPDATES_TARBALL_FILENAME}" ]; then
2425
		create_sha256 ${UPDATES_TARBALL_FILENAME}
2426
		cp -l ${UPDATES_TARBALL_FILENAME}* $STAGINGAREA/ 2>/dev/null
2427
		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${UPDATES_TARBALL_FILENAME})
2428
	fi
2429

    
2430
	if [ -f "${OVAPATH}" ]; then
2431
		mkdir -p ${STAGINGAREA}/virtualization
2432
		create_sha256 ${OVAPATH}
2433
		cp -l ${OVAPATH}* $STAGINGAREA/virtualization 2>/dev/null
2434
		snapshots_create_latest_symlink ${STAGINGAREA}/virtualization/$(basename ${OVAPATH})
2435
	fi
2436

    
2437
	# NOTE: Updates need a file with output similar to date output
2438
	# Use the file generated at start of snapshots_dobuilds() to be consistent on times
2439
	if [ -z "${_IS_RELEASE}" ]; then
2440
		cp $BUILTDATESTRINGFILE $STAGINGAREA/version 2>/dev/null
2441
	fi
2442
}
2443

    
2444
snapshots_scp_files() {
2445
	if [ -z "${RSYNC_COPY_ARGUMENTS}" ]; then
2446
		RSYNC_COPY_ARGUMENTS="-ave ssh --timeout=60 --bwlimit=${RSYNCKBYTELIMIT}" #--bwlimit=50
2447
	fi
2448

    
2449
	snapshots_update_status ">>> Copying core pkg repo to ${PKG_RSYNC_HOSTNAME}"
2450
	# Add ./ before last directory, it's an rsync trick to make it chdir to parent directory before sending
2451
	pkg_repo_rsync $(echo "${CORE_PKG_PATH}" | sed -E 's,/$,,; s,/([^/]*)$,/./\1,')
2452
	snapshots_update_status ">>> Finished copying core pkg repo"
2453

    
2454
	snapshots_update_status ">>> Copying files to ${RSYNCIP}"
2455

    
2456
	# Ensure directory(s) are available
2457
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/installer"
2458
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/updates"
2459
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/nanobsd"
2460
	if [ -d $STAGINGAREA/virtualization ]; then
2461
		ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/virtualization"
2462
	fi
2463
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/.updaters"
2464
	# ensure permissions are correct for r+w
2465
	ssh ${RSYNCUSER}@${RSYNCIP} "chmod -R ug+rw ${RSYNCPATH}/."
2466
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-*iso* \
2467
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/installer/
2468
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-memstick* \
2469
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/installer/
2470
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-*Update* \
2471
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
2472
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsd/* \
2473
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/nanobsd/
2474
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsdupdates/* \
2475
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
2476
	if [ -d $STAGINGAREA/virtualization ]; then
2477
		rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/virtualization/* \
2478
			${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/virtualization/
2479
	fi
2480

    
2481
	# Rather than copy these twice, use ln to link to the latest one.
2482

    
2483
	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz"
2484
	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz.sha256"
2485

    
2486
	LATESTFILENAME=$(basename ${UPDATES_TARBALL_FILENAME})
2487
	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME} \
2488
		${RSYNCPATH}/.updaters/latest.tgz"
2489
	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME}.sha256 \
2490
		${RSYNCPATH}/.updaters/latest.tgz.sha256"
2491

    
2492
	for i in ${FLASH_SIZE}
2493
	do
2494
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
2495
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
2496
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
2497
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
2498

    
2499
		FILENAMEUPGRADE="$(nanobsd_image_filename ${i} nanobsd 1).gz"
2500
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
2501
			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
2502
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
2503
			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
2504

    
2505
		FILENAMEUPGRADE="$(nanobsd_image_filename ${i} nanobsd-vga 1).gz"
2506
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
2507
			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
2508
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
2509
			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
2510
	done
2511

    
2512
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/version* \
2513
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/.updaters
2514
	snapshots_update_status ">>> Finished copying files."
2515
}
(2-2/3)