Project

General

Profile

Download (78.3 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
	mkdir -p ${CORE_PKG_REAL_PATH}/All
156
	if ! pkg create -o ${CORE_PKG_REAL_PATH}/All -p ${_plist} -r ${_root} -m ${_metadir}; then
157
		echo ">>> ERROR: Error building package ${_template} ${_flavor}"
158
		print_error_pfS
159
	fi
160
}
161

    
162
# This routine will output that something went wrong
163
print_error_pfS() {
164
	echo
165
	echo "####################################"
166
	echo "Something went wrong, check errors!" >&2
167
	echo "####################################"
168
	echo
169
	echo "NOTE: a lot of times you can run './build.sh --clean-builder' to resolve."
170
	echo
171
	if [ "$1" != "" ]; then
172
		echo $1
173
	fi
174
	[ -n "${LOGFILE}" -a -f "${LOGFILE}" ] && \
175
		echo "Log saved on ${LOGFILE}" && \
176
		tail -n20 ${LOGFILE} >&2
177
	echo
178
	kill $$
179
	exit 1
180
}
181

    
182
prestage_on_ram_setup() {
183
	[ -d "${STAGE_CHROOT_DIR}" ] \
184
		|| mkdir -p ${STAGE_CHROOT_DIR}
185
	[ -d "${FINAL_CHROOT_DIR}" ] \
186
		|| mkdir -p ${FINAL_CHROOT_DIR}
187

    
188
	_AVAIL_MEM=$(($(sysctl -n hw.usermem) / 1024 / 1024))
189
	if [ $_AVAIL_MEM -lt 2000 ]; then
190
		echo ">>> Builder has less than 2GiB RAM skipping memory disks"
191
		return
192
	else
193
		echo "######################################################################################"
194
		echo
195
		echo ">>> Builder has more than 2GiB RAM enabling memory disks"
196
		echo ">>> WARNING: Remember to remove these memory disks by running $0 --disable-memorydisks"
197
		echo
198
		echo "######################################################################################"
199
	fi
200

    
201
	if df /dev/ufs/prestagebacking >/dev/null 2>&1; then
202
		echo ">>> Detected preexisting memory disk enabled for ${STAGE_CHROOT_DIR}."
203
	else
204
		mdconfig -a -t swap -u 10001 -s ${MEMORYDISK_SIZE}
205
		newfs -L prestagebacking -U /dev/md10001
206
		mount /dev/ufs/prestagebacking ${STAGE_CHROOT_DIR}
207
	fi
208

    
209
	if df /dev/ufs/finalstagebacking >/dev/null 2>&1; then
210
		echo ">>> Detected preexisting memory disk enabled for ${FINAL_CHROOT_DIR}."
211
	else
212
		mdconfig -a -t swap -u 10002 -s ${MEMORYDISK_SIZE}
213
		newfs -L finalstagebacking -U /dev/md10002
214
		mount /dev/ufs/finalstagebacking ${FINAL_CHROOT_DIR}
215
	fi
216
}
217

    
218
prestage_on_ram_cleanup() {
219
	if [ -c /dev/md10001 ]; then
220
		if [ -d ${STAGE_CHROOT_DIR} ]; then
221
			umount ${STAGE_CHROOT_DIR}
222
		fi
223
		mdconfig -d -u 10001
224
	fi
225
	if [ -c /dev/md10002 ]; then
226
		if [ -d ${FINAL_CHROOT_DIR} ]; then
227
			umount ${FINAL_CHROOT_DIR}
228
		fi
229
		mdconfig -d -u 10002
230
	fi
231
}
232

    
233
# This routine will verify that the kernel has been
234
# installed OK to the staging area.
235
ensure_kernel_exists() {
236
	if [ ! -f "$1/boot/kernel/kernel.gz" ]; then
237
		echo ">>> ERROR: Could not locate $1/boot/kernel.gz"
238
		print_error_pfS
239
	fi
240
	KERNEL_SIZE=$(stat -f "%z" $1/boot/kernel/kernel.gz)
241
	if [ "$KERNEL_SIZE" -lt 3500 ]; then
242
		echo ">>> ERROR: Kernel $1/boot/kernel.gz appears to be smaller than it should be: $KERNEL_SIZE"
243
		print_error_pfS
244
	fi
245
}
246

    
247
get_pkg_name() {
248
	echo "${PRODUCT_NAME}-${1}-${CORE_PKG_VERSION}"
249
}
250

    
251
# This routine builds all related kernels
252
build_all_kernels() {
253
	# Set KERNEL_BUILD_PATH if it has not been set
254
	if [ -z "${KERNEL_BUILD_PATH}" ]; then
255
		KERNEL_BUILD_PATH=$SCRATCHDIR/kernels
256
		echo ">>> KERNEL_BUILD_PATH has not been set. Setting to ${KERNEL_BUILD_PATH}!"
257
	fi
258

    
259
	[ -d "${KERNEL_BUILD_PATH}" ] \
260
		&& rm -rf ${KERNEL_BUILD_PATH}
261

    
262
	# Build embedded kernel
263
	for BUILD_KERNEL in $BUILD_KERNELS; do
264
		unset KERNCONF
265
		unset KERNEL_DESTDIR
266
		unset KERNELCONF
267
		unset KERNEL_NAME
268
		export KERNCONF=$BUILD_KERNEL
269
		export KERNEL_DESTDIR="$KERNEL_BUILD_PATH/$BUILD_KERNEL"
270
		export KERNELCONF="${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/$BUILD_KERNEL"
271
		export KERNEL_NAME=${BUILD_KERNEL}
272

    
273
		LOGFILE="${BUILDER_LOGS}/kernel.${KERNCONF}.${TARGET}.log"
274
		echo ">>> Building $BUILD_KERNEL kernel."  | tee -a ${LOGFILE}
275

    
276
		if [ ! -e "${FREEBSD_SRC_DIR}/sys/${TARGET}/conf/${BUILD_KERNEL}" ]; then
277
			echo ">>> ERROR: Could not find $KERNELCONF"
278
			print_error_pfS
279
		fi
280

    
281
		if [ -n "${NO_BUILDKERNEL}" -a -f "${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz" ]; then
282
			echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}
283
			continue
284
		fi
285

    
286
		export SRC_CONF=${SRC_CONF}
287
		buildkernel
288

    
289
		echo ">>> Staging $BUILD_KERNEL kernel..." | tee -a ${LOGFILE}
290
		installkernel
291

    
292
		ensure_kernel_exists $KERNEL_DESTDIR
293

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

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

    
301
		rm -rf $KERNEL_DESTDIR 2>&1 1>/dev/null
302

    
303
		echo ".Done" | tee -a ${LOGFILE}
304
	done
305
}
306

    
307
install_default_kernel() {
308
	if [ -z "${1}" ]; then
309
		echo ">>> ERROR: install_default_kernel called without a kernel config name"| tee -a ${LOGFILE}
310
		print_error_pfS
311
	fi
312

    
313
	export KERNEL_NAME="${1}"
314

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

    
317
	# Copy kernel package to chroot, otherwise pkg won't find it to install
318
	if ! pkg_chroot_add ${FINAL_CHROOT_DIR} kernel-${KERNEL_NAME}; then
319
		echo ">>> ERROR: Error installing kernel package $(get_pkg_name kernel-${KERNEL_NAME}).txz" | tee -a ${LOGFILE}
320
		print_error_pfS
321
	fi
322

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

    
326
	if [ ! -f $FINAL_CHROOT_DIR/boot/kernel/kernel.gz ]; then
327
		echo ">>> ERROR: No kernel installed on $FINAL_CHROOT_DIR and the resulting image will be unusable. STOPPING!" | tee -a ${LOGFILE}
328
		print_error_pfS
329
	fi
330
	mkdir -p $FINAL_CHROOT_DIR/pkgs
331
	if [ -z "${2}" -o -n "${INSTALL_EXTRA_KERNELS}" ]; then
332
		cp ${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${KERNEL_NAME}).txz $FINAL_CHROOT_DIR/pkgs
333
		if [ -n "${INSTALL_EXTRA_KERNELS}" ]; then
334
			for _EXTRA_KERNEL in $INSTALL_EXTRA_KERNELS; do
335
				_EXTRA_KERNEL_PATH=${CORE_PKG_REAL_PATH}/All/$(get_pkg_name kernel-${_EXTRA_KERNEL}).txz
336
				if [ -f "${_EXTRA_KERNEL_PATH}" ]; then
337
					echo -n ". adding ${_EXTRA_KERNEL_PATH} on image /pkgs folder"
338
					cp ${_EXTRA_KERNEL_PATH} $FINAL_CHROOT_DIR/pkgs
339
				else
340
					echo ">>> ERROR: Requested kernel $(get_pkg_name kernel-${_EXTRA_KERNEL}).txz was not found to be put on image /pkgs folder!"
341
					print_error_pfS
342
				fi
343
			done
344
		fi
345
	fi
346
	echo "Done." | tee -a ${LOGFILE}
347

    
348
	unset KERNEL_NAME
349
}
350

    
351
# Creates a full update file
352
create_Full_update_tarball() {
353
	mkdir -p $UPDATESDIR
354

    
355
	customize_stagearea_for_image "fullupdate"
356
	install_default_kernel ${DEFAULT_KERNEL}
357

    
358
	rm -rf ${FINAL_CHROOT_DIR}/cf
359
	rm -rf ${FINAL_CHROOT_DIR}/conf
360
	rm -f ${FINAL_CHROOT_DIR}/etc/dh-parameters.*
361
	rm -f ${FINAL_CHROOT_DIR}/etc/rc.conf
362
	rm -f ${FINAL_CHROOT_DIR}/etc/pwd.db 2>/dev/null
363
	rm -f ${FINAL_CHROOT_DIR}/etc/group 2>/dev/null
364
	rm -f ${FINAL_CHROOT_DIR}/etc/spwd.db 2>/dev/null
365
	rm -f ${FINAL_CHROOT_DIR}/etc/passwd 2>/dev/null
366
	rm -f ${FINAL_CHROOT_DIR}/etc/master.passwd 2>/dev/null
367
	rm -f ${FINAL_CHROOT_DIR}/etc/fstab 2>/dev/null
368
	rm -f ${FINAL_CHROOT_DIR}/etc/bogons 2>/dev/null
369
	# Remove loader.conf and friends.  Ticket #560
370
	rm ${FINAL_CHROOT_DIR}/boot/loader.conf 2>/dev/null
371
	rm ${FINAL_CHROOT_DIR}/boot/loader.conf.local 2>/dev/null
372

    
373
	# Old systems will run (pre|post)_upgrade_command from /tmp
374
	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command ]; then
375
		cp -p \
376
			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/pre_upgrade_command \
377
			${FINAL_CHROOT_DIR}/tmp
378
	fi
379
	if [ -f ${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command ]; then
380
		cp -p \
381
			${FINAL_CHROOT_DIR}${PRODUCT_SHARE_DIR}/post_upgrade_command \
382
			${FINAL_CHROOT_DIR}/tmp
383
	fi
384

    
385
	echo ">>> Creating ${UPDATES_TARBALL_FILENAME} ..." | tee -a ${LOGFILE}
386
	tar --exclude=./dev -czPf ${UPDATES_TARBALL_FILENAME} -C ${FINAL_CHROOT_DIR} .
387
}
388

    
389
# Outputs various set variables aka env
390
print_flags() {
391

    
392
	echo
393
	printf "             Product version: %s\n" $PRODUCT_VERSION
394
	printf "                   Stage DIR: %s\n" $STAGE_CHROOT_DIR
395
	printf "                 Updates dir: %s\n" $UPDATESDIR
396
	printf " Image Preparation Stage DIR: %s\n" $FINAL_CHROOT_DIR
397
	printf "                  Source DIR: %s\n" $FREEBSD_SRC_DIR
398
	printf "          FreeBSD repository: %s\n" $FREEBSD_REPO_BASE
399
	printf "          FreeBSD-src branch: %s\n" $FREEBSD_BRANCH
400
	printf "     FreeBSD original branch: %s\n" $FREEBSD_PARENT_BRANCH
401
	printf "               BUILD_KERNELS: %s\n" $BUILD_KERNELS
402
	printf "           Git Branch or Tag: %s\n" $GIT_REPO_BRANCH_OR_TAG
403
	printf "            MODULES_OVERRIDE: %s\n" $MODULES_OVERRIDE
404
	printf "    VMDK_DISK_CAPACITY_IN_GB: %s\n" $VMDK_DISK_CAPACITY_IN_GB
405
	printf "   OVA_FIRST_PART_SIZE_IN_GB: %s\n" $OVA_FIRST_PART_SIZE_IN_GB
406
	printf "    OVA_SWAP_PART_SIZE_IN_GB: %s\n" $OVA_SWAP_PART_SIZE_IN_GB
407
	printf "                 OVFTEMPLATE: %s\n" $OVFTEMPLATE
408
	printf "                     OVFVMDK: %s\n" $OVFVMDK
409
	printf "                    SRC_CONF: %s\n" $SRC_CONF
410
	printf "                     ISOPATH: %s\n" $ISOPATH
411
	printf "                MEMSTICKPATH: %s\n" $MEMSTICKPATH
412
	printf "    UPDATES_TARBALL_FILENAME: %s\n" $UPDATES_TARBALL_FILENAME
413
if [ -n "$SHOW_ENV" ]; then
414
	for LINE in $(env | egrep -v '(terminal|PASS|NAME|USER|SSH|GROUP|HOST)'); do
415
		echo "SHOW_ENV: $LINE"
416
	done
417
fi
418
	echo
419
}
420

    
421
# This builds FreeBSD (make buildworld)
422
# Imported from FreeSBIE
423
make_world() {
424

    
425
	LOGFILE=${BUILDER_LOGS}/buildworld.${TARGET}
426
	if [ -n "${NO_BUILDWORLD}" ]; then
427
		echo ">>> NO_BUILDWORLD set, skipping build" | tee -a ${LOGFILE}
428
		return
429
	fi
430

    
431
	# Set SRC_CONF variable if it's not already set.
432
	if [ -z "${SRC_CONF}" ]; then
433
		echo ">>> SRC_CONF is unset make sure this is what you want!" | tee -a ${LOGFILE}
434
	else
435
		echo ">>> Setting SRC_CONF to $SRC_CONF" | tee -a ${LOGFILE}
436
	fi
437

    
438
	# Set default parameters
439
	export MAKE_ARGS="${MAKEJ_WORLD} __MAKE_CONF=${MAKE_CONF} SRCCONF=${SRC_CONF} TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH}"
440

    
441
	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}
442
	makeargs="${MAKE_ARGS}"
443
	echo ">>> Building world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
444
	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}
445
	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} -DNO_CLEAN ${makeargs} buildworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
446
	echo ">>> Building world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
447

    
448
	LOGFILE=${BUILDER_LOGS}/installworld.${TARGET}
449
	echo ">>> LOGFILE set to $LOGFILE." | tee -a ${LOGFILE}
450
	# Create if cleaned up
451
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR} WITHOUT_TOOLCHAIN=1"
452
	echo ">>> Installing world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
453
	echo ">>> Builder is running the command: env LOCAL_ITOOLS=\"${EXTRA_TOOLS}\" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld" | tee -a ${LOGFILE}
454
	(env LOCAL_ITOOLS="${EXTRA_TOOLS}" script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installworld || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
455
	echo ">>> Installing world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
456

    
457
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"
458
	echo ">>> Distribution world for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
459
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution " | tee -a ${LOGFILE}
460
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} distribution  || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
461
	echo ">>> Distribution world for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
462

    
463
	[ -d "${STAGE_CHROOT_DIR}/usr/local/bin" ] \
464
		|| mkdir -p ${STAGE_CHROOT_DIR}/usr/local/bin
465
	makeargs="${MAKE_ARGS} DESTDIR=${STAGE_CHROOT_DIR}"
466
	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Starting - $(LC_ALL=C date))" | tee -a ${LOGFILE}
467
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install " | tee -a ${LOGFILE}
468
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/crypto ${makeargs} clean all install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
469
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean" | tee -a ${LOGFILE}
470
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} clean || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
471
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} all" | tee -a ${LOGFILE}
472
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} all || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
473
	echo ">>> Builder is running the command: script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} install" | tee -a ${LOGFILE}
474
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR}/tools/tools/ath/athstats ${makeargs} install || print_error_pfS;) | egrep '^>>>' | tee -a ${LOGFILE}
475
	echo ">>> Building and installing crypto tools and athstats for ${TARGET} architecture... (Finished - $(LC_ALL=C date))" | tee -a ${LOGFILE}
476

    
477
	unset makeargs
478
}
479

    
480
nanobsd_image_filename() {
481
	local _size="$1"
482
	local _type="$2"
483
	local _upgrade="$3"
484

    
485
	if [ -z "$upgrade" ]; then
486
		local _template=${NANOBSD_IMG_TEMPLATE}
487
	else
488
		local _template=${NANOBSD_UPGRADE_TEMPLATE}
489
	fi
490

    
491
	echo "$_template" | sed \
492
		-e "s,%%SIZE%%,${_size},g" \
493
		-e "s,%%TYPE%%,${_type},g"
494

    
495
	return 0
496
}
497

    
498
# This routine originated in nanobsd.sh
499
nanobsd_set_flash_details () {
500
	a1=$(echo $1 | tr '[:upper:]' '[:lower:]')
501

    
502
	# Source:
503
	#	SanDisk CompactFlash Memory Card
504
	#	Product Manual
505
	#	Version 10.9
506
	#	Document No. 20-10-00038
507
	#	April 2005
508
	# Table 2-7
509
	# NB: notice math error in SDCFJ-4096-388 line.
510
	#
511
	case "${a1}" in
512
		2048|2048m|2048mb|2g)
513
			NANO_MEDIASIZE=$((1989999616/512))
514
			;;
515
		4096|4096m|4096mb|4g)
516
			NANO_MEDIASIZE=$((3989999616/512))
517
			;;
518
		8192|8192m|8192mb|8g)
519
			NANO_MEDIASIZE=$((7989999616/512))
520
			;;
521
		16384|16384m|16384mb|16g)
522
			NANO_MEDIASIZE=$((15989999616/512))
523
			;;
524
		*)
525
			echo "Unknown Flash capacity"
526
			exit 2
527
			;;
528
	esac
529

    
530
	NANO_HEADS=16
531
	NANO_SECTS=63
532

    
533
	echo ">>> [nanoo] $1"
534
	echo ">>> [nanoo] NANO_MEDIASIZE: $NANO_MEDIASIZE"
535
	echo ">>> [nanoo] NANO_HEADS: $NANO_HEADS"
536
	echo ">>> [nanoo] NANO_SECTS: $NANO_SECTS"
537
	echo ">>> [nanoo] NANO_BOOT0CFG: $NANO_BOOT0CFG"
538
}
539

    
540
# This routine originated in nanobsd.sh
541
create_nanobsd_diskimage () {
542
	if [ -z "${1}" ]; then
543
		echo ">>> ERROR: Type of image has not been specified"
544
		print_error_pfS
545
	fi
546
	if [ -z "${2}" ]; then
547
		echo ">>> ERROR: Size of image has not been specified"
548
		print_error_pfS
549
	fi
550

    
551
	if [ "${1}" = "nanobsd" ]; then
552
		# It's serial
553
		export NANO_BOOTLOADER="boot/boot0sio"
554
	elif [ "${1}" = "nanobsd-vga" ]; then
555
		# It's vga
556
		export NANO_BOOTLOADER="boot/boot0"
557
	else
558
		echo ">>> ERROR: Type of image to create unknown"
559
		print_error_pfS
560
	fi
561

    
562
	if [ -z "${2}" ]; then
563
		echo ">>> ERROR: Media size(s) not specified."
564
		print_error_pfS
565
	fi
566

    
567
	if [ -z "${2}" ]; then
568
		echo ">>> ERROR: FLASH_SIZE is not set."
569
		print_error_pfS
570
	fi
571

    
572
	LOGFILE=${BUILDER_LOGS}/${1}.${TARGET}
573
	# Prepare folder to be put in image
574
	customize_stagearea_for_image "${1}"
575
	install_default_kernel ${DEFAULT_KERNEL} "no"
576

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

    
579
	echo "nanobsd" > $FINAL_CHROOT_DIR/etc/platform
580

    
581
	local BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
582
	local LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
583

    
584
	if [ "${1}" = "nanobsd" ]; then
585
		# Tell loader to use serial console early.
586
		echo "-S115200 -h" >> ${BOOTCONF}
587

    
588
		# Remove old console options if present.
589
		[ -f "${LOADERCONF}" ] \
590
			&& sed -i "" -Ee "/(console|boot_multicons|boot_serial|hint.uart)/d" ${LOADERCONF}
591
		# Activate serial console+video console in loader.conf
592
		echo 'loader_color="NO"' >> ${LOADERCONF}
593
		echo 'beastie_disable="YES"' >> ${LOADERCONF}
594
		echo 'boot_serial="YES"' >> ${LOADERCONF}
595
		echo 'console="comconsole"' >> ${LOADERCONF}
596
		echo 'comconsole_speed="115200"' >> ${LOADERCONF}
597
	fi
598
	echo 'autoboot_delay="5"' >> ${LOADERCONF}
599

    
600
	for _NANO_MEDIASIZE in ${2}; do
601
		if [ -z "${_NANO_MEDIASIZE}" ]; then
602
			continue;
603
		fi
604

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

    
608
		IMG="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1})"
609
		IMGUPDATE="${IMAGES_FINAL_DIR}/$(nanobsd_image_filename ${_NANO_MEDIASIZE} ${1} 1)"
610

    
611
		nanobsd_set_flash_details ${_NANO_MEDIASIZE}
612

    
613
		# These are defined in FlashDevice and on builder_default.sh
614
		echo $NANO_MEDIASIZE \
615
			$NANO_IMAGES \
616
			$NANO_SECTS \
617
			$NANO_HEADS \
618
			$NANO_CODESIZE \
619
			$NANO_CONFSIZE \
620
			$NANO_DATASIZE |
621
awk '
622
{
623
	printf "# %s\n", $0
624

    
625
	# size of cylinder in sectors
626
	cs = $3 * $4
627

    
628
	# number of full cylinders on media
629
	cyl = int ($1 / cs)
630

    
631
	# output fdisk geometry spec, truncate cyls to 1023
632
	if (cyl <= 1023)
633
		print "g c" cyl " h" $4 " s" $3
634
	else
635
		print "g c" 1023 " h" $4 " s" $3
636

    
637
	if ($7 > 0) {
638
		# size of data partition in full cylinders
639
		dsl = int (($7 + cs - 1) / cs)
640
	} else {
641
		dsl = 0;
642
	}
643

    
644
	# size of config partition in full cylinders
645
	csl = int (($6 + cs - 1) / cs)
646

    
647
	if ($5 == 0) {
648
		# size of image partition(s) in full cylinders
649
		isl = int ((cyl - dsl - csl) / $2)
650
	} else {
651
		isl = int (($5 + cs - 1) / cs)
652
	}
653

    
654
	# First image partition start at second track
655
	print "p 1 165 " $3, isl * cs - $3
656
	c = isl * cs;
657

    
658
	# Second image partition (if any) also starts offset one
659
	# track to keep them identical.
660
	if ($2 > 1) {
661
		print "p 2 165 " $3 + c, isl * cs - $3
662
		c += isl * cs;
663
	}
664

    
665
	# Config partition starts at cylinder boundary.
666
	print "p 3 165 " c, csl * cs
667
	c += csl * cs
668

    
669
	# Data partition (if any) starts at cylinder boundary.
670
	if ($7 > 0) {
671
		print "p 4 165 " c, dsl * cs
672
	} else if ($7 < 0 && $1 > c) {
673
		print "p 4 165 " c, $1 - c
674
	} else if ($1 < c) {
675
		print "Disk space overcommitted by", \
676
		    c - $1, "sectors" > "/dev/stderr"
677
		exit 2
678
	}
679

    
680
	# Force slice 1 to be marked active. This is necessary
681
	# for booting the image from a USB device to work.
682
	print "a 1"
683
}
684
	' > ${IMAGES_FINAL_DIR}/_.fdisk
685

    
686
		MNT=${IMAGES_FINAL_DIR}/_.mnt
687
		mkdir -p ${MNT}
688

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

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

    
695
		fdisk -i -f ${IMAGES_FINAL_DIR}/_.fdisk ${MD} 2>&1 >> ${LOGFILE}
696
		fdisk ${MD} 2>&1 >> ${LOGFILE}
697

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

    
700
		# Create first image
701
		bsdlabel -m i386 -w -B -b ${FINAL_CHROOT_DIR}/boot/boot ${MD}s1 2>&1 >> ${LOGFILE}
702
		bsdlabel -m i386 ${MD}s1 2>&1 >> ${LOGFILE}
703
		local _label=$(lc ${PRODUCT_NAME})
704
		newfs -L ${_label}0 ${NANO_NEWFS} /dev/${MD}s1a 2>&1 >> ${LOGFILE}
705
		mount /dev/ufs/${_label}0 ${MNT}
706
		if [ $? -ne 0 ]; then
707
			echo ">>> ERROR: Something wrong happened during mount of first slice image creation. STOPPING!" | tee -a ${LOGFILE}
708
			print_error_pfS
709
		fi
710
		# Consider the unmounting as well
711
		trap "umount /dev/ufs/${_label}0; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
712

    
713
		clone_directory_contents ${FINAL_CHROOT_DIR} ${MNT}
714

    
715
		# Set NanoBSD image size
716
		echo "${_NANO_MEDIASIZE}" > ${MNT}/etc/nanosize.txt
717

    
718
		echo "/dev/ufs/${_label}0 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab
719
		if [ $NANO_CONFSIZE -gt 0 ] ; then
720
			echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab
721
		fi
722

    
723
		umount ${MNT}
724
		# Restore the original trap
725
		trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
726

    
727
		# Setting NANO_IMAGES to 1 and NANO_INIT_IMG2 will tell
728
		# NanoBSD to only create one partition.  We default to 2
729
		# partitions in case anything happens to the first the
730
		# operator can boot from the 2nd and should be OK.
731

    
732
		# Before just going to use dd for duplicate think!
733
		# The images are created as sparse so lets take advantage
734
		# of that by just exec some commands.
735
		if [ $NANO_IMAGES -gt 1 -a $NANO_INIT_IMG2 -gt 0 ] ; then
736
			# Duplicate to second image (if present)
737
			echo ">>> Creating NanoBSD second slice by duplicating first slice." | tee -a ${LOGFILE}
738
			# Create second image
739
			dd if=/dev/${MD}s1 of=/dev/${MD}s2 conv=sparse bs=64k 2>&1 >> ${LOGFILE}
740
			tunefs -L ${_label}1 /dev/${MD}s2a 2>&1 >> ${LOGFILE}
741
			mount /dev/ufs/${_label}1 ${MNT}
742
			if [ $? -ne 0 ]; then
743
				echo ">>> ERROR: Something wrong happened during mount of second slice image creation. STOPPING!" | tee -a ${LOGFILE}
744
				print_error_pfS
745
			fi
746
			# Consider the unmounting as well
747
			trap "umount /dev/ufs/${_label}1; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
748

    
749
			echo "/dev/ufs/${_label}1 / ufs ro,sync,noatime 1 1" > ${MNT}/etc/fstab
750
			if [ $NANO_CONFSIZE -gt 0 ] ; then
751
				echo "/dev/ufs/cf /cf ufs ro,sync,noatime 1 1" >> ${MNT}/etc/fstab
752
			fi
753

    
754
			umount ${MNT}
755
			# Restore the trap back
756
			trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
757
		fi
758

    
759
		# Create Data slice, if any.
760
		# Note the changing of the variable to NANO_CONFSIZE
761
		# from NANO_DATASIZE.  We also added glabel support
762
		# and populate the Product configuration from the /cf
763
		# directory located in FINAL_CHROOT_DIR
764
		if [ $NANO_CONFSIZE -gt 0 ] ; then
765
			echo ">>> Creating /cf area to hold config.xml"
766
			newfs -L cf ${NANO_NEWFS} /dev/${MD}s3 2>&1 >> ${LOGFILE}
767
			# Mount data partition and copy contents of /cf
768
			# Can be used later to create custom default config.xml while building
769
			mount /dev/ufs/cf ${MNT}
770
			if [ $? -ne 0 ]; then
771
				echo ">>> ERROR: Something wrong happened during mount of cf slice image creation. STOPPING!" | tee -a ${LOGFILE}
772
				print_error_pfS
773
			fi
774
			# Consider the unmounting as well
775
			trap "umount /dev/ufs/cf; mdconfig -d -u ${MD}; return" 1 2 15 EXIT
776

    
777
			clone_directory_contents ${FINAL_CHROOT_DIR}/cf ${MNT}
778

    
779
			umount ${MNT}
780
			# Restore the trap back
781
			trap "mdconfig -d -u ${MD}; return" 1 2 15 EXIT
782
		else
783
			">>> [nanoo] NANO_CONFSIZE is not set. Not adding a /conf partition.. You sure about this??" | tee -a ${LOGFILE}
784
		fi
785

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

    
789
		mdconfig -d -u $MD
790
		# Restore default action
791
		trap "-" 1 2 15 EXIT
792

    
793
		# Check each image and ensure that they are over
794
		# 3 megabytes.  If either image is under 20 megabytes
795
		# in size then error out.
796
		IMGSIZE=$(stat -f "%z" ${IMG})
797
		IMGUPDATESIZE=$(stat -f "%z" ${IMGUPDATE})
798
		CHECKSIZE="20040710"
799
		if [ "$IMGSIZE" -lt "$CHECKSIZE" ]; then
800
			echo ">>> ERROR: Something went wrong when building NanoBSD.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}
801
			print_error_pfS
802
		fi
803
		if [ "$IMGUPDATESIZE" -lt "$CHECKSIZE" ]; then
804
			echo ">>> ERROR: Something went wrong when building NanoBSD upgrade image.  The image size is under 20 megabytes!" | tee -a ${LOGFILE}
805
			print_error_pfS
806
		fi
807

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

    
811
		gzip -qf $IMG &
812
		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
813
		gzip -qf $IMGUPDATE &
814
		_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
815
	done
816

    
817
	unset IMG
818
	unset IMGUPDATE
819
	unset IMGUPDATESIZE
820
	unset IMGSIZE
821

    
822
	ls -lah $IMAGES_FINAL_DIR
823
}
824

    
825
# This routine creates a ova image that contains
826
# a ovf and vmdk file. These files can be imported
827
# right into vmware or virtual box.
828
# (and many other emulation platforms)
829
# http://www.vmware.com/pdf/ovf_whitepaper_specification.pdf
830
create_ova_image() {
831
	# XXX create a .ovf php creator that you can pass:
832
	#     1. populatedSize
833
	#     2. license
834
	#     3. product name
835
	#     4. version
836
	#     5. number of network interface cards
837
	#     6. allocationUnits
838
	#     7. capacity
839
	#     8. capacityAllocationUnits
840

    
841
	LOGFILE=${BUILDER_LOGS}/ova.${TARGET}.log
842

    
843
	[ -d "${OVA_TMP}" ] \
844
		&& rm -rf ${OVA_TMP}
845

    
846
	mkdir -p ${OVA_TMP}
847

    
848
	# Prepare folder to be put in image
849
	customize_stagearea_for_image "ova"
850
	install_default_kernel ${DEFAULT_KERNEL} "no"
851

    
852
	# Fill fstab
853
	echo ">>> Installing platform specific items..." | tee -a ${LOGFILE}
854
	echo "/dev/gpt/${PRODUCT_NAME}	/	ufs		rw	0	0" > ${FINAL_CHROOT_DIR}/etc/fstab
855
	echo "/dev/gpt/swap0	none	swap	sw	0	0" >> ${FINAL_CHROOT_DIR}/etc/fstab
856

    
857
	# Create / partition
858
	echo -n ">>> Creating / partition... " | tee -a ${LOGFILE}
859
	makefs \
860
		-B little \
861
		-o label=${PRODUCT_NAME} \
862
		-s ${OVA_FIRST_PART_SIZE_IN_GB}g \
863
		${OVA_TMP}/${OVFUFS} \
864
		${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
865

    
866
	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFUFS} ]; then
867
		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
868
			rm -f ${OVA_TMP}/${OVFUFS}
869
		fi
870
		echo "Failed!" | tee -a ${LOGFILE}
871
		echo ">>> ERROR: Error creating vmdk / partition. STOPPING!" | tee -a ${LOGFILE}
872
		print_error_pfS
873
	fi
874
	echo "Done!" | tee -a ${LOGFILE}
875

    
876
	# Create raw disk
877
	echo -n ">>> Creating raw disk... " | tee -a ${LOGFILE}
878
	mkimg \
879
		-s gpt \
880
		-f raw \
881
		-b /boot/pmbr \
882
		-p freebsd-boot:=/boot/gptboot \
883
		-p freebsd-ufs/${PRODUCT_NAME}:=${OVA_TMP}/${OVFUFS} \
884
		-p freebsd-swap/swap0::${OVA_SWAP_PART_SIZE} \
885
		-o ${OVA_TMP}/${OVFRAW} 2>&1 >> ${LOGFILE}
886

    
887
	if [ $? -ne 0 -o ! -f ${OVA_TMP}/${OVFRAW} ]; then
888
		if [ -f ${OVA_TMP}/${OVFUFS} ]; then
889
			rm -f ${OVA_TMP}/${OVFUFS}
890
		fi
891
		if [ -f ${OVA_TMP}/${OVFRAW} ]; then
892
			rm -f ${OVA_TMP}/${OVFRAW}
893
		fi
894
		echo "Failed!" | tee -a ${LOGFILE}
895
		echo ">>> ERROR: Error creating temporary vmdk image. STOPPING!" | tee -a ${LOGFILE}
896
		print_error_pfS
897
	fi
898
	echo "Done!" | tee -a ${LOGFILE}
899

    
900
	# We don't need it anymore
901
	rm -f ${OVA_TMP}/${OVFUFS} >/dev/null 2>&1
902

    
903
	# Convert raw to vmdk
904
	echo -n ">>> Creating vmdk disk... " | tee -a ${LOGFILE}
905
	vmdktool -z9 -v ${OVA_TMP}/${OVFVMDK} ${OVA_TMP}/${OVFRAW}
906

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

    
920
	rm -f ${OVA_TMP}/i${OVFRAW}
921

    
922
	ova_setup_ovf_template
923

    
924
	echo -n ">>> Writing final ova image... " | tee -a ${LOGFILE}
925
	# Create OVA file for vmware
926
	gtar -C ${OVA_TMP} -cpf ${OVAPATH} ${PRODUCT_NAME}.ovf ${OVFVMDK}
927
	echo "Done!" | tee -a ${LOGFILE}
928
	rm -f ${OVA_TMP}/${OVFVMDK} >/dev/null 2>&1
929

    
930
	echo ">>> OVA created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
931
}
932

    
933
# called from create_ova_image
934
ova_setup_ovf_template() {
935
	if [ ! -f ${OVFTEMPLATE} ]; then
936
		echo ">>> ERROR: OVF template file (${OVFTEMPLATE}) not found."
937
		print_error_pfS
938
	fi
939

    
940
	#  OperatingSystemSection (${PRODUCT_NAME}.ovf)
941
	#  42   FreeBSD 32-Bit
942
	#  78   FreeBSD 64-Bit
943
	if [ "${TARGET}" = "amd64" ]; then
944
		local _os_id="78"
945
		local _os_type="freebsd64Guest"
946
		local _os_descr="FreeBSD 64-Bit"
947
	elif [ "${TARGET}" = "i386" ]; then
948
		local _os_id="42"
949
		local _os_type="freebsdGuest"
950
		local _os_descr="FreeBSD"
951
	else
952
		echo ">>> ERROR: Platform not supported for OVA (${TARGET})"
953
		print_error_pfS
954
	fi
955

    
956
	local POPULATED_SIZE=$(du -d0 -k $FINAL_CHROOT_DIR | cut -f1)
957
	local POPULATED_SIZE_IN_BYTES=$((${POPULATED_SIZE}*1024))
958
	local VMDK_FILE_SIZE=$(stat -f "%z" ${OVA_TMP}/${OVFVMDK})
959

    
960
	sed \
961
		-e "s,%%VMDK_FILE_SIZE%%,${VMDK_FILE_SIZE},g" \
962
		-e "s,%%VMDK_DISK_CAPACITY_IN_GB%%,${VMDK_DISK_CAPACITY_IN_GB},g" \
963
		-e "s,%%POPULATED_SIZE_IN_BYTES%%,${POPULATED_SIZE_IN_BYTES},g" \
964
		-e "s,%%OS_ID%%,${_os_id},g" \
965
		-e "s,%%OS_TYPE%%,${_os_type},g" \
966
		-e "s,%%OS_DESCR%%,${_os_descr},g" \
967
		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
968
		-e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION},g" \
969
		-e "s,%%PRODUCT_URL%%,${PRODUCT_URL},g" \
970
		-e "/^%%PRODUCT_LICENSE%%/r ${BUILDER_ROOT}/license.txt" \
971
		-e "/^%%PRODUCT_LICENSE%%/d" \
972
		${OVFTEMPLATE} > ${OVA_TMP}/${PRODUCT_NAME}.ovf
973
}
974

    
975
# Cleans up previous builds
976
clean_builder() {
977
	# Clean out directories
978
	echo ">>> Cleaning up previous build environment...Please wait!"
979

    
980
	staginareas_clean_each_run
981

    
982
	if [ -d "${STAGE_CHROOT_DIR}" ]; then
983
		BASENAME=$(basename ${STAGE_CHROOT_DIR})
984
		echo -n ">>> Cleaning ${STAGE_CHROOT_DIR} ..."
985
		chflags -R noschg ${STAGE_CHROOT_DIR} 2>&1 >/dev/null
986
		rm -rf ${STAGE_CHROOT_DIR}/* 2>/dev/null
987
		echo "Done."
988
	fi
989

    
990
	if [ -z "${NO_CLEAN_FREEBSD_OBJ}" -a -d "${FREEBSD_SRC_DIR}" ]; then
991
		OBJTREE=$(env TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} make -C ${FREEBSD_SRC_DIR} -V OBJTREE)
992
		if [ -d "${OBJTREE}" ]; then
993
			echo -n ">>> Cleaning FreeBSD objects dir staging..."
994
			echo -n "."
995
			chflags -R noschg ${OBJTREE} 2>&1 >/dev/null
996
			echo -n "."
997
			rm -rf ${OBJTREE}/*
998
			echo "Done!"
999
		fi
1000
		if [ -d "${KERNEL_BUILD_PATH}" ]; then
1001
			echo -n ">>> Cleaning previously built kernel stage area..."
1002
			rm -rf $KERNEL_BUILD_PATH/*
1003
			echo "Done!"
1004
		fi
1005
	fi
1006
	mkdir -p $KERNEL_BUILD_PATH
1007

    
1008
	echo -n ">>> Cleaning previously built images..."
1009
	rm -rf $IMAGES_FINAL_DIR/*
1010
	rm -rf $STAGINGAREA/*
1011
	echo "Done!"
1012

    
1013
	if [ -z "${NO_CLEAN_FREEBSD_SRC}" ]; then
1014
		if [ -d "$FREEBSD_SRC_DIR" ]; then
1015
			echo -n ">>> Ensuring $FREEBSD_SRC_DIR is clean..."
1016
			rm -rf ${FREEBSD_SRC_DIR}
1017
			echo "Done!"
1018
		fi
1019
	fi
1020

    
1021
	echo -n ">>> Cleaning previous builder logs..."
1022
	if [ -d "$BUILDER_LOGS" ]; then
1023
		rm -rf ${BUILDER_LOGS}
1024
	fi
1025
	mkdir -p ${BUILDER_LOGS}
1026

    
1027
	echo "Done!"
1028

    
1029
	echo ">>> Cleaning of builder environment has finished."
1030
}
1031

    
1032
clone_directory_contents() {
1033
	if [ ! -d "$1" -o ! -d "$2" ]; then
1034
		if [ -z "${LOGFILE}" ]; then
1035
			echo ">>> ERROR: Argument $1 supplied is not a directory!"
1036
		else
1037
			echo ">>> ERROR: Argument $1 supplied is not a directory!" | tee -a ${LOGFILE}
1038
		fi
1039
		print_error_pfS
1040
	fi
1041
	echo -n ">>> Using TAR to clone $1 to $2 ..."
1042
	tar -C ${1} -c -f - . | tar -C ${2} -x -p -f -
1043
	echo "Done!"
1044
}
1045

    
1046
clone_to_staging_area() {
1047
	# Clone everything to the final staging area
1048
	echo -n ">>> Cloning everything to ${STAGE_CHROOT_DIR} staging area..."
1049
	LOGFILE=${BUILDER_LOGS}/cloning.${TARGET}.log
1050

    
1051
	tar -C ${PRODUCT_SRC} -c -f - . | \
1052
		tar -C ${STAGE_CHROOT_DIR} -x -p -f -
1053

    
1054
	if [ "${PRODUCT_NAME}" != "pfSense" ]; then
1055
		mv ${STAGE_CHROOT_DIR}/usr/local/sbin/pfSense-upgrade \
1056
			${STAGE_CHROOT_DIR}/usr/local/sbin/${PRODUCT_NAME}-upgrade
1057
	fi
1058

    
1059
	if [ -f ${STAGE_CHROOT_DIR}/etc/master.passwd ]; then
1060
		chroot ${STAGE_CHROOT_DIR} cap_mkdb /etc/master.passwd
1061
		chroot ${STAGE_CHROOT_DIR} pwd_mkdb /etc/master.passwd
1062
	fi
1063
	mkdir -p ${STAGE_CHROOT_DIR}/etc/mtree
1064
	mtree -Pcp ${STAGE_CHROOT_DIR}/var > ${STAGE_CHROOT_DIR}/etc/mtree/var.dist
1065
	mtree -Pcp ${STAGE_CHROOT_DIR}/etc > ${STAGE_CHROOT_DIR}/etc/mtree/etc.dist
1066
	if [ -d ${STAGE_CHROOT_DIR}/usr/local/etc ]; then
1067
		mtree -Pcp ${STAGE_CHROOT_DIR}/usr/local/etc > ${STAGE_CHROOT_DIR}/etc/mtree/localetc.dist
1068
	fi
1069

    
1070
	## Add buildtime and lastcommit information
1071
	# This is used for detecting updates.
1072
	echo "$BUILTDATESTRING" > $STAGE_CHROOT_DIR/etc/version.buildtime
1073
	# Record last commit info if it is available.
1074
	if [ -f $SCRATCHDIR/build_commit_info.txt ]; then
1075
		cp $SCRATCHDIR/build_commit_info.txt $STAGE_CHROOT_DIR/etc/version.lastcommit
1076
	fi
1077

    
1078
	local _exclude_files="${CORE_PKG_TMP}/base_exclude_files"
1079
	sed \
1080
		-e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" \
1081
		-e "s,%%VERSION%%,${_version},g" \
1082
		${BUILDER_TOOLS}/templates/core_pkg/base/exclude_files \
1083
		> ${_exclude_files}
1084

    
1085
	mkdir -p ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR} >/dev/null 2>&1
1086

    
1087
	# Include a sample pkg stable conf to base
1088
	setup_pkg_repo \
1089
		${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo.conf \
1090
		${TARGET} \
1091
		${TARGET_ARCH} \
1092
		${PKG_REPO_CONF_BRANCH} \
1093
		"release"
1094

    
1095
	# Include a sample pkg devel conf to base
1096
	setup_pkg_repo \
1097
		${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo-devel.conf \
1098
		${TARGET} \
1099
		${TARGET_ARCH} \
1100
		${PKG_REPO_CONF_BRANCH}
1101

    
1102
	mtree \
1103
		-c \
1104
		-k uid,gid,mode,size,flags,sha256digest \
1105
		-p ${STAGE_CHROOT_DIR} \
1106
		-X ${_exclude_files} \
1107
		> ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.mtree
1108
	tar \
1109
		-C ${STAGE_CHROOT_DIR} \
1110
		-cJf ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/base.txz \
1111
		-X ${_exclude_files} \
1112
		.
1113

    
1114
	mkdir -p $(dirname ${STAGE_CHROOT_DIR}${PKG_REPO_PATH}) >/dev/null 2>&1
1115

    
1116
	# Create repo and repo-devel packages
1117
	cp -f ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo.conf \
1118
		${STAGE_CHROOT_DIR}${PKG_REPO_PATH}
1119

    
1120
	core_pkg_create repo "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1121

    
1122
	cp -f ${STAGE_CHROOT_DIR}${PRODUCT_SHARE_DIR}/${PRODUCT_NAME}-repo-devel.conf \
1123
		${STAGE_CHROOT_DIR}${PKG_REPO_PATH}
1124

    
1125
	core_pkg_create repo-devel "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1126

    
1127
	rm -f ${STAGE_CHROOT_DIR}${PKG_REPO_PATH}
1128

    
1129
	core_pkg_create rc "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1130
	core_pkg_create base "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1131
	core_pkg_create base-nanobsd "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1132
	core_pkg_create default-config "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1133

    
1134
	local DEFAULTCONF=${STAGE_CHROOT_DIR}/conf.default/config.xml
1135

    
1136
	# Save current WAN and LAN if value
1137
	local _old_wan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/wan/if" ${DEFAULTCONF})
1138
	local _old_lan_if=$(xml sel -t -v "${XML_ROOTOBJ}/interfaces/lan/if" ${DEFAULTCONF})
1139

    
1140
	# Change default interface names to match vmware driver
1141
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "vmx0" ${DEFAULTCONF}
1142
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "vmx1" ${DEFAULTCONF}
1143
	core_pkg_create default-config "vmware" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1144

    
1145
	# Restore default values to be used by serial package
1146
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/wan/if" -v "${_old_wan_if}" ${DEFAULTCONF}
1147
	xml ed -P -L -u "${XML_ROOTOBJ}/interfaces/lan/if" -v "${_old_lan_if}" ${DEFAULTCONF}
1148

    
1149
	# Activate serial console in config.xml
1150
	xml ed -L -P -d "${XML_ROOTOBJ}/system/enableserial" ${DEFAULTCONF}
1151
	xml ed -P -s "${XML_ROOTOBJ}/system" -t elem -n "enableserial" \
1152
		${DEFAULTCONF} > ${DEFAULTCONF}.tmp
1153
	xml fo -t ${DEFAULTCONF}.tmp > ${DEFAULTCONF}
1154
	rm -f ${DEFAULTCONF}.tmp
1155

    
1156
	echo force > ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force
1157

    
1158
	core_pkg_create default-config-serial "" ${CORE_PKG_VERSION} ${STAGE_CHROOT_DIR}
1159

    
1160
	rm -f ${STAGE_CHROOT_DIR}/cf/conf/enableserial_force
1161
	rm -f ${STAGE_CHROOT_DIR}/cf/conf/config.xml
1162

    
1163
	# Make sure pkg is present
1164
	pkg_bootstrap ${STAGE_CHROOT_DIR}
1165

    
1166
	echo "Done!"
1167
}
1168

    
1169
create_final_staging_area() {
1170
	if [ -z "${FINAL_CHROOT_DIR}" ]; then
1171
		echo ">>> ERROR: FINAL_CHROOT_DIR is not set, cannot continue!" | tee -a ${LOGFILE}
1172
		print_error_pfS
1173
	fi
1174

    
1175
	if [ -d "${FINAL_CHROOT_DIR}" ]; then
1176
		echo -n ">>> Previous ${FINAL_CHROOT_DIR} detected cleaning up..." | tee -a ${LOGFILE}
1177
		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 1>/dev/null
1178
		rm -rf ${FINAL_CHROOT_DIR}/* 2>&1 1>/dev/null
1179
		echo "Done." | tee -a ${LOGFILE}
1180
	fi
1181

    
1182
	echo ">>> Preparing Final image staging area: $(LC_ALL=C date)" 2>&1 | tee -a ${LOGFILE}
1183
	echo ">>> Cloning ${STAGE_CHROOT_DIR} to ${FINAL_CHROOT_DIR}" 2>&1 | tee -a ${LOGFILE}
1184
	clone_directory_contents ${STAGE_CHROOT_DIR} ${FINAL_CHROOT_DIR}
1185

    
1186
	if [ ! -f $FINAL_CHROOT_DIR/sbin/init ]; then
1187
		echo ">>> ERROR: Something went wrong during cloning -- Please verify!" 2>&1 | tee -a ${LOGFILE}
1188
		print_error_pfS
1189
	fi
1190
}
1191

    
1192
customize_stagearea_for_image() {
1193
	local _image_type="$1"
1194
	local _default_config=""
1195

    
1196
	if [ -n "$2" ]; then
1197
		_default_config="$2"
1198
	elif [ "${_image_type}" = "nanobsd" -o \
1199
	     "${_image_type}" = "memstickserial" -o \
1200
	     "${_image_type}" = "memstickadi" ]; then
1201
		_default_config="default-config-serial"
1202
	elif [ "${_image_type}" = "ova" ]; then
1203
		_default_config="default-config-vmware"
1204
	else
1205
		_default_config="default-config"
1206
	fi
1207

    
1208
	# Prepare final stage area
1209
	create_final_staging_area
1210

    
1211
	pkg_chroot_add ${FINAL_CHROOT_DIR} rc
1212

    
1213
	if [ "${_image_type}" = "nanobsd" -o \
1214
	     "${_image_type}" = "nanobsd-vga" ]; then
1215

    
1216
		mkdir -p ${FINAL_CHROOT_DIR}/root/var/db \
1217
			 ${FINAL_CHROOT_DIR}/root/var/cache \
1218
			 ${FINAL_CHROOT_DIR}/var/db/pkg \
1219
			 ${FINAL_CHROOT_DIR}/var/cache/pkg
1220
		mv -f ${FINAL_CHROOT_DIR}/var/db/pkg ${FINAL_CHROOT_DIR}/root/var/db
1221
		mv -f ${FINAL_CHROOT_DIR}/var/cache/pkg ${FINAL_CHROOT_DIR}/root/var/cache
1222
		ln -sf ../../root/var/db/pkg ${FINAL_CHROOT_DIR}/var/db/pkg
1223
		ln -sf ../../root/var/cache/pkg ${FINAL_CHROOT_DIR}/var/cache/pkg
1224

    
1225
		pkg_chroot_add ${FINAL_CHROOT_DIR} base-nanobsd
1226
	else
1227
		pkg_chroot_add ${FINAL_CHROOT_DIR} base
1228
	fi
1229

    
1230
	if [ -n "${IS_RELEASE}" ]; then
1231
		pkg_chroot_add ${FINAL_CHROOT_DIR} repo
1232
	else
1233
		pkg_chroot_add ${FINAL_CHROOT_DIR} repo-devel
1234
	fi
1235

    
1236
	if [ "${_image_type}" = "iso" -o \
1237
	     "${_image_type}" = "memstick" -o \
1238
	     "${_image_type}" = "memstickserial" -o \
1239
	     "${_image_type}" = "memstickadi" ]; then
1240
		install_bsdinstaller
1241
		mkdir -p ${FINAL_CHROOT_DIR}/pkgs
1242
		cp ${CORE_PKG_REAL_PATH}/All/*default-config*.txz ${FINAL_CHROOT_DIR}/pkgs
1243
	fi
1244

    
1245
	pkg_chroot_add ${FINAL_CHROOT_DIR} ${_default_config}
1246
}
1247

    
1248
create_distribution_tarball() {
1249
	mkdir -p ${FINAL_CHROOT_DIR}/install
1250

    
1251
	tar -C ${FINAL_CHROOT_DIR} --exclude ./install --exclude ./pkgs -cJf ${FINAL_CHROOT_DIR}/install/${PRODUCT_NAME}.txz .
1252
}
1253

    
1254
create_iso_image() {
1255
	LOGFILE=${BUILDER_LOGS}/isoimage.${TARGET}
1256
	echo ">>> Building bootable ISO image for ${TARGET}" | tee -a ${LOGFILE}
1257
	if [ -z "${DEFAULT_KERNEL}" ]; then
1258
		echo ">>> ERROR: Could not identify DEFAULT_KERNEL to install on image!" | tee -a ${LOGFILE}
1259
		print_error_pfS
1260
	fi
1261

    
1262
	customize_stagearea_for_image "iso"
1263
	install_default_kernel ${DEFAULT_KERNEL}
1264

    
1265
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1266

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

    
1270
	# This check is for supporting create memstick/ova images
1271
	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}
1272
	echo "-o label=${FSLABEL} -o publisher=\"${PRODUCT_NAME} project.\" $ISOPATH ${FINAL_CHROOT_DIR}" | tee -a ${LOGFILE}
1273

    
1274
	create_distribution_tarball
1275

    
1276
	# Remove /rescue from iso since cd9660 cannot deal with hardlinks
1277
	rm -rf ${FINAL_CHROOT_DIR}/rescue
1278

    
1279
	makefs -t cd9660 -o bootimage="i386;${FINAL_CHROOT_DIR}/boot/cdboot" -o no-emul-boot -o rockridge \
1280
		-o label=${FSLABEL} -o publisher="${PRODUCT_NAME} project." $ISOPATH ${FINAL_CHROOT_DIR} 2>&1 >> ${LOGFILE}
1281
	if [ $? -ne 0 -o ! -f $ISOPATH ]; then
1282
		if [ -f ${ISOPATH} ]; then
1283
			rm -f $ISOPATH
1284
		fi
1285
		echo ">>> ERROR: Something wrong happened during ISO image creation. STOPPING!" | tee -a ${LOGFILE}
1286
		print_error_pfS
1287
	fi
1288
	gzip -qf $ISOPATH &
1289
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1290

    
1291
	echo ">>> ISO created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1292
}
1293

    
1294
create_memstick_image() {
1295

    
1296
	LOGFILE=${BUILDER_LOGS}/memstick.${TARGET}
1297
	if [ "${MEMSTICKPATH}" = "" ]; then
1298
		echo ">>> MEMSTICKPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1299
		return
1300
	fi
1301

    
1302
	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
1303
		customize_stagearea_for_image "memstick"
1304
		install_default_kernel ${DEFAULT_KERNEL}
1305
	fi
1306

    
1307
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1308

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

    
1313
	create_distribution_tarball
1314

    
1315
	makefs -B little -o label=${PRODUCT_NAME} ${MEMSTICKPATH} ${FINAL_CHROOT_DIR}
1316
	if [ $? -ne 0 ]; then
1317
		if [ -f ${MEMSTICKPATH} ]; then
1318
			rm -f $MEMSTICKPATH
1319
		fi
1320
		echo ">>> ERROR: Something wrong happened during MEMSTICK image creation. STOPPING!" | tee -a ${LOGFILE}
1321
		print_error_pfS
1322
	fi
1323
	MD=$(mdconfig -a -t vnode -f $MEMSTICKPATH)
1324
	# Just in case
1325
	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
1326
	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}|
1327
	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
1328
	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
1329
	trap "-" 1 2 15 EXIT
1330
	mdconfig -d -u ${MD} 2>&1 | tee -a ${LOGFILE}
1331
	gzip -qf $MEMSTICKPATH &
1332
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1333

    
1334
	echo ">>> MEMSTICK created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1335
}
1336

    
1337
create_memstick_serial_image() {
1338
	LOGFILE=${BUILDER_LOGS}/memstickserial.${TARGET}
1339
	if [ "${MEMSTICKSERIALPATH}" = "" ]; then
1340
		echo ">>> MEMSTICKSERIALPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1341
		return
1342
	fi
1343

    
1344
	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
1345
		customize_stagearea_for_image "memstickserial"
1346
		install_default_kernel ${DEFAULT_KERNEL}
1347
	fi
1348

    
1349
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1350

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

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

    
1356
	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
1357
	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
1358

    
1359
	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
1360
	# Activate serial console in boot.config
1361
	if [ -f ${BOOTCONF} ]; then
1362
		sed -i "" '/-D$/d' ${BOOTCONF}
1363
	fi
1364
	echo "-S115200 -D" >> ${BOOTCONF}
1365

    
1366
	# Remove old console options if present.
1367
	[ -f "${LOADERCONF}" ] \
1368
		&& sed -i "" -Ee "/(console|boot_multicons|boot_serial)/d" ${LOADERCONF}
1369
	# Activate serial console+video console in loader.conf
1370
	echo 'boot_multicons="YES"' >>  ${LOADERCONF}
1371
	echo 'boot_serial="YES"' >> ${LOADERCONF}
1372
	echo 'console="comconsole,vidconsole"' >> ${LOADERCONF}
1373
	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
1374

    
1375
	create_distribution_tarball
1376

    
1377
	makefs -B little -o label=${PRODUCT_NAME} ${MEMSTICKSERIALPATH} ${FINAL_CHROOT_DIR}
1378
	if [ $? -ne 0 ]; then
1379
		if [ -f ${MEMSTICKSERIALPATH} ]; then
1380
			rm -f $MEMSTICKSERIALPATH
1381
		fi
1382
		echo ">>> ERROR: Something wrong happened during MEMSTICKSERIAL image creation. STOPPING!" | tee -a ${LOGFILE}
1383
		print_error_pfS
1384
	fi
1385
	MD=$(mdconfig -a -t vnode -f $MEMSTICKSERIALPATH)
1386
	# Just in case
1387
	trap "mdconfig -d -u ${MD}" 1 2 15 EXIT
1388
	gpart create -s BSD ${MD} 2>&1 >> ${LOGFILE}
1389
	gpart bootcode -b ${FINAL_CHROOT_DIR}/boot/boot ${MD} 2>&1 >> ${LOGFILE}
1390
	gpart add -t freebsd-ufs ${MD} 2>&1 >> ${LOGFILE}
1391
	trap "-" 1 2 15 EXIT
1392
	mdconfig -d -u ${MD} 2>&1 >> ${LOGFILE}
1393
	gzip -qf $MEMSTICKSERIALPATH &
1394
	_bg_pids="${_bg_pids}${_bg_pids:+ }$!"
1395

    
1396
	echo ">>> MEMSTICKSERIAL created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1397
}
1398

    
1399
create_memstick_adi_image() {
1400
	LOGFILE=${BUILDER_LOGS}/memstickadi${TARGET}
1401
	if [ "${MEMSTICKADIPATH}" = "" ]; then
1402
		echo ">>> MEMSTICKADIPATH is empty skipping generation of memstick image!" | tee -a ${LOGFILE}
1403
		return
1404
	fi
1405

    
1406
	if [ ! -d ${FINAL_CHROOT_DIR}/boot ]; then
1407
		customize_stagearea_for_image "memstickadi"
1408
		install_default_kernel ${DEFAULT_KERNEL}
1409
	fi
1410

    
1411
	echo cdrom > $FINAL_CHROOT_DIR/etc/platform
1412

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

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

    
1418
	BOOTCONF=${FINAL_CHROOT_DIR}/boot.config
1419
	LOADERCONF=${FINAL_CHROOT_DIR}/boot/loader.conf
1420

    
1421
	echo ">>> Activating serial console..." 2>&1 | tee -a ${LOGFILE}
1422
	# Activate serial console in boot.config
1423
	if [ -f ${BOOTCONF} ]; then
1424
		sed -i "" '/-[Dh]$/d' ${BOOTCONF}
1425
	fi
1426
	echo "-S115200 -h" >> ${BOOTCONF}
1427

    
1428
	# Remove old console options if present.
1429
	[ -f "${LOADERCONF}" ] \
1430
		&& sed -i "" -Ee "/(console|boot_multicons|boot_serial|hint.uart)/d" ${LOADERCONF}
1431
	# Activate serial console+video console in loader.conf
1432
	echo 'boot_serial="YES"' >> ${LOADERCONF}
1433
	echo 'console="comconsole"' >> ${LOADERCONF}
1434
	echo 'comconsole_speed="115200"' >> ${LOADERCONF}
1435
	echo 'comconsole_port="0x2F8"' >> ${LOADERCONF}
1436
	echo 'hint.uart.0.flags="0x00"' >> ${LOADERCONF}
1437
	echo 'hint.uart.1.flags="0x10"' >> ${LOADERCONF}
1438

    
1439
	create_distribution_tarball
1440

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

    
1460
	echo ">>> MEMSTICKADI created: $(LC_ALL=C date)" | tee -a ${LOGFILE}
1461
}
1462

    
1463
# Create pkg conf on desired place with desired arch/branch
1464
setup_pkg_repo() {
1465
	if [ -z "${4}" ]; then
1466
		return
1467
	fi
1468

    
1469
	local _target="${1}"
1470
	local _arch="${2}"
1471
	local _target_arch="${3}"
1472
	local _branch="${4}"
1473
	local _release="${5}"
1474

    
1475
	if [ -n "${_release}" ]; then
1476
		local _template="${PKG_REPO_TEMPLATE}"
1477
	else
1478
		local _template="${PKG_REPO_DEVEL_TEMPLATE}"
1479
	fi
1480

    
1481
	if [ -z "${_template}" -o ! -f "${_template}" ]; then
1482
		echo ">>> ERROR: It was not possible to find pkg conf template ${_template}"
1483
		print_error_pfS
1484
	fi
1485

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

    
1488
	sed \
1489
		-e "s/%%ARCH%%/${_arch}_${_target_arch}/" \
1490
		-e "s/%%GIT_REPO_BRANCH_OR_TAG%%/${_branch}/g" \
1491
		-e "s,%%PKG_REPO_SERVER%%,${PKG_REPO_SERVER},g" \
1492
		-e "s/%%PRODUCT_NAME%%/${PRODUCT_NAME}/g" \
1493
		${_template} \
1494
		> ${_target}
1495
}
1496

    
1497
# This routine ensures any ports / binaries that the builder
1498
# system needs are on disk and ready for execution.
1499
builder_setup() {
1500
	# If Product-builder is already installed, just leave
1501
	if pkg info -e -q ${PRODUCT_NAME}-builder; then
1502
		return
1503
	fi
1504

    
1505
	if [ ! -f ${PKG_REPO_PATH} ]; then
1506
		[ -d $(dirname ${PKG_REPO_PATH}) ] \
1507
			|| mkdir -p $(dirname ${PKG_REPO_PATH})
1508

    
1509
		update_freebsd_sources
1510

    
1511
		local _arch=$(uname -m)
1512
		setup_pkg_repo \
1513
			${PKG_REPO_PATH} \
1514
			${_arch} \
1515
			${_arch} \
1516
			${PKG_REPO_CONF_BRANCH} \
1517
			${IS_RELEASE}
1518

    
1519
		# Use fingerprint keys from repo
1520
		sed -i '' -e "/fingerprints:/ s,\"/,\"${BUILDER_ROOT}/src/," \
1521
			${PKG_REPO_PATH}
1522
	fi
1523

    
1524
	pkg install ${PRODUCT_NAME}-builder
1525
}
1526

    
1527
# Updates FreeBSD sources
1528
update_freebsd_sources() {
1529
	if [ "${1}" = "full" ]; then
1530
		local _full=1
1531
		local _clone_params=""
1532
	else
1533
		local _full=0
1534
		local _clone_params="--depth 1 --single-branch"
1535
	fi
1536

    
1537
	if [ ! -d "${FREEBSD_SRC_DIR}" ]; then
1538
		mkdir -p ${FREEBSD_SRC_DIR}
1539
	fi
1540

    
1541
	if [ -n "${NO_BUILDWORLD}" -a -n "${NO_BUILDKERNEL}" ]; then
1542
		echo ">>> NO_BUILDWORLD and NO_BUILDKERNEL set, skipping update of freebsd sources" | tee -a ${LOGFILE}
1543
		return
1544
	fi
1545

    
1546
	echo -n ">>> Obtaining FreeBSD sources ${FREEBSD_BRANCH}..."
1547
	local _FREEBSD_BRANCH=${FREEBSD_BRANCH:-"devel"}
1548
	local _CLONE=1
1549

    
1550
	if [ -d "${FREEBSD_SRC_DIR}/.git" ]; then
1551
		CUR_BRANCH=$(cd ${FREEBSD_SRC_DIR} && git branch | grep '^\*' | cut -d' ' -f2)
1552
		if [ ${_full} -eq 0 -a "${CUR_BRANCH}" = "${_FREEBSD_BRANCH}" ]; then
1553
			_CLONE=0
1554
			( cd ${FREEBSD_SRC_DIR} && git clean -fd; git fetch origin; git reset --hard origin/${_FREEBSD_BRANCH} ) 2>&1 | grep -C3 -i -E 'error|fatal'
1555
		else
1556
			rm -rf ${FREEBSD_SRC_DIR}
1557
		fi
1558
	fi
1559

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

    
1564
	if [ ! -d "${FREEBSD_SRC_DIR}/.git" ]; then
1565
		echo ">>> ERROR: It was not possible to clone FreeBSD src repo"
1566
		print_error_pfS
1567
	fi
1568

    
1569
	if [ -n "${GIT_FREEBSD_COSHA1}" ]; then
1570
		( cd ${FREEBSD_SRC_DIR} && git checkout ${GIT_FREEBSD_COSHA1} ) 2>&1 | grep -C3 -i -E 'error|fatal'
1571
	fi
1572
	echo "Done!"
1573
}
1574

    
1575
pkg_chroot() {
1576
	local _root="${1}"
1577
	shift
1578

    
1579
	if [ $# -eq 0 ]; then
1580
		return -1
1581
	fi
1582

    
1583
	if [ -z "${_root}" -o "${_root}" = "/" -o ! -d "${_root}" ]; then
1584
		return -1
1585
	fi
1586

    
1587
	mkdir -p \
1588
		${SCRATCHDIR}/pkg_cache \
1589
		${_root}/var/cache/pkg \
1590
		${_root}/dev
1591

    
1592
	/sbin/mount -t nullfs ${SCRATCHDIR}/pkg_cache ${_root}/var/cache/pkg
1593
	/sbin/mount -t devfs devfs ${_root}/dev
1594
	cp -f /etc/resolv.conf ${_root}/etc/resolv.conf
1595
	touch ${BUILDER_LOGS}/install_pkg_install_ports.txt
1596
	script -aq ${BUILDER_LOGS}/install_pkg_install_ports.txt pkg -c ${_root} $@ >/dev/null 2>&1
1597
	rm -f ${_root}/etc/resolv.conf
1598
	/sbin/umount -f ${_root}/dev
1599
	/sbin/umount -f ${_root}/var/cache/pkg
1600
}
1601

    
1602

    
1603
pkg_chroot_add() {
1604
	if [ -z "${1}" -o -z "${2}" ]; then
1605
		return 1
1606
	fi
1607

    
1608
	local _target="${1}"
1609
	local _pkg="$(get_pkg_name ${2}).txz"
1610

    
1611
	if [ ! -d "${_target}" ]; then
1612
		echo ">>> ERROR: Target dir ${_target} not found"
1613
		print_error_pfS
1614
	fi
1615

    
1616
	if [ ! -f ${CORE_PKG_REAL_PATH}/All/${_pkg} ]; then
1617
		echo ">>> ERROR: Package ${_pkg} not found"
1618
		print_error_pfS
1619
	fi
1620

    
1621
	cp ${CORE_PKG_REAL_PATH}/All/${_pkg} ${_target}
1622
	pkg_chroot ${_target} add /${_pkg}
1623
	rm -f ${_target}/${_pkg}
1624
}
1625

    
1626
pkg_bootstrap() {
1627
	local _root=${1:-"${STAGE_CHROOT_DIR}"}
1628

    
1629
	setup_pkg_repo \
1630
		${_root}${PKG_REPO_PATH} \
1631
		${TARGET} \
1632
		${TARGET_ARCH} \
1633
		${PKG_REPO_CONF_BRANCH} \
1634
		${IS_RELEASE}
1635

    
1636
	pkg_chroot ${_root} bootstrap -f
1637
}
1638

    
1639
# This routine assists with installing various
1640
# freebsd ports files into the pfsense-fs staging
1641
# area.
1642
install_pkg_install_ports() {
1643
	local MAIN_PKG="${1}"
1644

    
1645
	if [ -z "${MAIN_PKG}" ]; then
1646
		MAIN_PKG=${PRODUCT_NAME}
1647
	fi
1648

    
1649
	echo ">>> Installing pkg repository in chroot (${STAGE_CHROOT_DIR})..."
1650

    
1651
	[ -d ${STAGE_CHROOT_DIR}/var/cache/pkg ] || \
1652
		mkdir -p ${STAGE_CHROOT_DIR}/var/cache/pkg
1653

    
1654
	[ -d ${SCRATCHDIR}/pkg_cache ] || \
1655
		mkdir -p ${SCRATCHDIR}/pkg_cache
1656

    
1657
	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (starting)"
1658
	pkg_chroot ${STAGE_CHROOT_DIR} install ${MAIN_PKG} ${custom_package_list}
1659
	pkg_chroot ${STAGE_CHROOT_DIR} autoremove
1660
	echo ">>> Installing built ports (packages) in chroot (${STAGE_CHROOT_DIR})... (finshied)"
1661
}
1662

    
1663
install_bsdinstaller() {
1664
	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (starting)"
1665
	pkg_chroot ${FINAL_CHROOT_DIR} install -f bsdinstaller
1666
	sed -i '' -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME}," \
1667
		  -e "s,%%PRODUCT_VERSION%%,${PRODUCT_VERSION}," \
1668
		  -e "s,%%ARCH%%,${TARGET}," \
1669
		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense.lua \
1670
		  ${FINAL_CHROOT_DIR}/usr/local/share/dfuibe_lua/conf/pfSense_rescue.lua
1671
	echo ">>> Installing BSDInstaller in chroot (${FINAL_CHROOT_DIR})... (finished)"
1672
}
1673

    
1674
staginareas_clean_each_run() {
1675
	echo -n ">>> Cleaning build directories: "
1676
	if [ -d "${FINAL_CHROOT_DIR}" ]; then
1677
		BASENAME=$(basename ${FINAL_CHROOT_DIR})
1678
		echo -n "$BASENAME "
1679
		chflags -R noschg ${FINAL_CHROOT_DIR} 2>&1 >/dev/null
1680
		rm -rf ${FINAL_CHROOT_DIR}/* 2>/dev/null
1681
	fi
1682
	echo "Done!"
1683
}
1684

    
1685
# Imported from FreeSBIE
1686
buildkernel() {
1687
	if [ -n "${NO_BUILDKERNEL}" ]; then
1688
		echo ">>> NO_BUILDKERNEL set, skipping build" | tee -a ${LOGFILE}
1689
		return
1690
	fi
1691

    
1692
	if [ -z "${KERNCONF}" ]; then
1693
		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
1694
		print_error_pfS
1695
	fi
1696

    
1697
	if [ -n "${KERNELCONF}" ]; then
1698
		export KERNCONFDIR=$(dirname ${KERNELCONF})
1699
		export KERNCONF=$(basename ${KERNELCONF})
1700
	fi
1701

    
1702
	SRCCONFBASENAME=$(basename ${SRC_CONF})
1703
	echo ">>> KERNCONFDIR: ${KERNCONFDIR}"
1704
	echo ">>> ARCH:        ${TARGET}"
1705
	echo ">>> SRC_CONF:    ${SRCCONFBASENAME}"
1706

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

    
1712
# Imported from FreeSBIE
1713
installkernel() {
1714
	if [ -z "${KERNCONF}" ]; then
1715
		echo ">>> ERROR: No kernel configuration defined probably this is not what you want! STOPPING!" | tee -a ${LOGFILE}
1716
		print_error_pfS
1717
	fi
1718

    
1719
	if [ -n "${KERNELCONF}" ]; then
1720
		export KERNCONFDIR=$(dirname ${KERNELCONF})
1721
		export KERNCONF=$(basename ${KERNELCONF})
1722
	fi
1723

    
1724
	mkdir -p ${STAGE_CHROOT_DIR}/boot
1725
	makeargs="${MAKEJ_KERNEL} SRCCONF=${SRC_CONF} __MAKE_CONF=${MAKE_CONF} TARGET_ARCH=${TARGET_ARCH} TARGET=${TARGET} DESTDIR=${KERNEL_DESTDIR}"
1726
	echo ">>> Builder is running the command: script -aq $LOGFILE make ${makeargs} installkernel KERNCONF=${KERNCONF}"  | tee -a $LOGFILE
1727
	(script -aq $LOGFILE make -C ${FREEBSD_SRC_DIR} ${makeargs} installkernel KERNCONF=${KERNCONF} || print_error_pfS;) | egrep '^>>>'
1728
	gzip -f9 $KERNEL_DESTDIR/boot/kernel/kernel
1729
}
1730

    
1731
# Launch is ran first to setup a few variables that we need
1732
# Imported from FreeSBIE
1733
launch() {
1734
	if [ "$(id -u)" != "0" ]; then
1735
		echo "Sorry, this must be done as root."
1736
	fi
1737

    
1738
	echo ">>> Operation $0 has started at $(date)"
1739
}
1740

    
1741
finish() {
1742
	echo ">>> Operation $0 has ended at $(date)"
1743
}
1744

    
1745
pkg_repo_rsync() {
1746
	local _repo_path="${1}"
1747

    
1748
	if [ -z "${_repo_path}" -o ! -d "${_repo_path}" ]; then
1749
		return
1750
	fi
1751

    
1752
	if [ -z "${LOGFILE}" ]; then
1753
		local _logfile="/dev/null"
1754
	else
1755
		local _logfile="${LOGFILE}"
1756
	fi
1757

    
1758
	if [ -n "${PKG_REPO_SIGNING_COMMAND}" ]; then
1759

    
1760
		# Detect poudriere directory structure
1761
		if [ -L "${_repo_path}/.latest" ]; then
1762
			local _real_repo_path=$(readlink -f ${_repo_path}/.latest)
1763
		else
1764
			local _real_repo_path=${_repo_path}
1765
		fi
1766

    
1767
		echo -n ">>> Signing repository... " | tee -a ${_logfile}
1768
		############ ATTENTION ##############
1769
		#
1770
		# For some reason pkg-repo fail without / in the end of directory name
1771
		# so removing it will break command
1772
		#
1773
		# https://github.com/freebsd/pkg/issues/1364
1774
		#
1775
		if script -aq ${_logfile} pkg repo ${_real_repo_path}/ \
1776
		    signing_command: ${PKG_REPO_SIGNING_COMMAND} >/dev/null 2>&1; then
1777
			echo "Done!" | tee -a ${_logfile}
1778
		else
1779
			echo "Failed!" | tee -a ${_logfile}
1780
			echo ">>> ERROR: An error occurred trying to sign repo"
1781
			print_error_pfS
1782
		fi
1783

    
1784
		local _pkgfile="${_repo_path}/Latest/pkg.txz"
1785
		if [ -e ${_pkgfile} ]; then
1786
			echo -n ">>> Signing Latest/pkg.txz for bootstraping... " | tee -a ${_logfile}
1787

    
1788
			if sha256 -q ${_pkgfile} | ${PKG_REPO_SIGNING_COMMAND} \
1789
			    > ${_pkgfile}.sig 2>/dev/null; then
1790
				echo "Done!" | tee -a ${_logfile}
1791
			else
1792
				echo "Failed!" | tee -a ${_logfile}
1793
				echo ">>> ERROR: An error occurred trying to sign Latest/pkg.txz"
1794
				print_error_pfS
1795
			fi
1796
		fi
1797
	fi
1798

    
1799
	if [ -n "${DO_NOT_UPLOAD}" ]; then
1800
		return
1801
	fi
1802

    
1803
	echo -n ">>> Sending updated repository to ${PKG_RSYNC_HOSTNAME}... " | tee -a ${_logfile}
1804
	if script -aq ${_logfile} rsync -ave "ssh -p ${PKG_RSYNC_SSH_PORT}" \
1805
		--timeout=60 --delete-delay ${_repo_path} \
1806
		${PKG_RSYNC_USERNAME}@${PKG_RSYNC_HOSTNAME}:${PKG_RSYNC_DESTDIR} >/dev/null 2>&1
1807
	then
1808
		echo "Done!" | tee -a ${_logfile}
1809
	else
1810
		echo "Failed!" | tee -a ${_logfile}
1811
		echo ">>> ERROR: An error occurred sending repo to remote hostname"
1812
		print_error_pfS
1813
	fi
1814
}
1815

    
1816
poudriere_create_patch() {
1817
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
1818

    
1819
	if [ -z "${FREEBSD_PARENT_BRANCH}" ]; then
1820
		echo ">>> ERROR: FREEBSD_PARENT_BRANCH is not set"
1821
	fi
1822

    
1823
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1824

    
1825
	# Get FreeBSD source and apply patches
1826
	update_freebsd_sources full
1827

    
1828
	[ -f "${_jail_patch}" ] && \
1829
		rm -f "${_jail_patch}"
1830

    
1831
	# Create a big patch with all our changes to use on jail
1832
	( \
1833
		cd ${FREEBSD_SRC_DIR} && \
1834
		git diff $(git merge-base origin/${FREEBSD_PARENT_BRANCH} ${FREEBSD_BRANCH}) > ${_jail_patch}
1835
	) >/dev/null 2>&1
1836

    
1837
	# Check if patch was created
1838
	if [ ! -s "${_jail_patch}" ]; then
1839
		echo ">>> ERROR: Patch does not exist or is empty, aborting..." | tee -a ${LOGFILE}
1840
		print_error_pfS
1841
	fi
1842
}
1843

    
1844
poudriere_possible_archs() {
1845
	local _arch=$(uname -m)
1846
	local _archs="i386.i386"
1847

    
1848
	# If host is amd64, we'll create both repos, and if possible armv6
1849
	if [ "${_arch}" = "amd64" ]; then
1850
		_archs="amd64.amd64 ${_archs}"
1851

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

    
1856
			if binmiscctl lookup armv6 >/dev/null 2>&1; then
1857
				_archs="${_archs} arm.armv6"
1858
			fi
1859
		fi
1860
	fi
1861

    
1862
	if [ -n "${ARCH_LIST}" ]; then
1863
		local _found=0
1864
		for _desired_arch in ${ARCH_LIST}; do
1865
			_found=0
1866
			for _possible_arch in ${_archs}; do
1867
				if [ "${_desired_arch}" = "${_possible_arch}" ]; then
1868
					_found=1
1869
					break
1870
				fi
1871
			done
1872
			if [ ${_found} -eq 0 ]; then
1873
				echo ">>> ERROR: Impossible to build for arch: ${_desired_arch}"
1874
				print_error_pfS
1875
			fi
1876
		done
1877
		_archs="${ARCH_LIST}"
1878
	fi
1879

    
1880
	echo ${_archs}
1881
}
1882

    
1883
poudriere_jail_name() {
1884
	local _jail_arch="${1}"
1885

    
1886
	if [ -z "${_jail_arch}" ]; then
1887
		return 1
1888
	fi
1889

    
1890
	# Poudriere doesn't like periods in jail names
1891
	_jail_arch=$(echo "${_jail_arch}" | tr '.' '_')
1892

    
1893
	echo "${PRODUCT_NAME}_${GIT_REPO_BRANCH_OR_TAG}_${_jail_arch}"
1894
}
1895

    
1896
poudriere_rename_ports() {
1897
	if [ "${PRODUCT_NAME}" = "pfSense" ]; then
1898
		return;
1899
	fi
1900

    
1901
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1902

    
1903
	local _ports_dir="/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}"
1904

    
1905
	echo -n ">>> Renaming product ports on ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
1906
	for d in $(find ${_ports_dir} -depth 2 -type d -name '*pfSense*'); do
1907
		local _pdir=$(dirname ${d})
1908
		local _pname=$(echo $(basename ${d}) | sed "s,pfSense,${PRODUCT_NAME},")
1909

    
1910
		if [ -e ${_pdir}/${_pname} ]; then
1911
			rm -rf ${_pdir}/${_pname}
1912
		fi
1913

    
1914
		cp -r ${d} ${_pdir}/${_pname}
1915

    
1916
		sed -i '' -e "s,pfSense,${PRODUCT_NAME},g" \
1917
			  -e "s,https://www.pfsense.org,${PRODUCT_URL},g" \
1918
			  -e "/^MAINTAINER=/ s,^.*$,MAINTAINER=	${PRODUCT_EMAIL}," \
1919
			${_pdir}/${_pname}/Makefile \
1920
			${_pdir}/${_pname}/pkg-descr
1921

    
1922
		# PHP module is special
1923
		if echo "${_pname}" | grep -q "^php[0-9]*-${PRODUCT_NAME}-module"; then
1924
			local _product_capital=$(echo ${PRODUCT_NAME} | tr '[a-z]' '[A-Z]')
1925
			sed -i '' -e "s,PHP_PFSENSE,PHP_${_product_capital},g" \
1926
				  -e "s,PFSENSE_SHARED_LIBADD,${_product_capital}_SHARED_LIBADD,g" \
1927
				  -e "s,pfSense,${PRODUCT_NAME},g" \
1928
				  -e "s,${PRODUCT_NAME}\.c,pfSense.c,g" \
1929
				${_pdir}/${_pname}/files/config.m4
1930

    
1931
			sed -i '' -e "s,COMPILE_DL_PFSENSE,COMPILE_DL_${_product_capital}," \
1932
				  -e "s,pfSense_module_entry,${PRODUCT_NAME}_module_entry,g" \
1933
				  -e "/ZEND_GET_MODULE/ s,pfSense,${PRODUCT_NAME}," \
1934
				  -e "/PHP_PFSENSE_WORLD_EXTNAME/ s,pfSense,${PRODUCT_NAME}," \
1935
				${_pdir}/${_pname}/files/pfSense.c \
1936
				${_pdir}/${_pname}/files/php_pfSense.h
1937
		fi
1938

    
1939
		if [ -d ${_pdir}/${_pname}/files ]; then
1940
			for fd in $(find ${_pdir}/${_pname}/files -type d -name '*pfSense*'); do
1941
				local _fddir=$(dirname ${fd})
1942
				local _fdname=$(echo $(basename ${fd}) | sed "s,pfSense,${PRODUCT_NAME},")
1943

    
1944
				mv ${fd} ${_fddir}/${_fdname}
1945
			done
1946
		fi
1947
	done
1948
	echo "Done!" | tee -a ${LOGFILE}
1949
}
1950

    
1951
poudriere_create_ports_tree() {
1952
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1953

    
1954
	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
1955
		local _branch=""
1956
		if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
1957
			echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
1958
			print_error_pfS
1959
		fi
1960
		if [ -n "${POUDRIERE_PORTS_GIT_BRANCH}" ]; then
1961
			_branch="-B ${POUDRIERE_PORTS_GIT_BRANCH}"
1962
		fi
1963
		echo -n ">>> Creating poudriere ports tree, it may take some time... " | tee -a ${LOGFILE}
1964
		if ! script -aq ${LOGFILE} poudriere ports -c -p "${POUDRIERE_PORTS_NAME}" -m git ${_branch} >/dev/null 2>&1; then
1965
			echo "" | tee -a ${LOGFILE}
1966
			echo ">>> ERROR: Error creating poudriere ports tree, aborting..." | tee -a ${LOGFILE}
1967
			print_error_pfS
1968
		fi
1969
		echo "Done!" | tee -a ${LOGFILE}
1970
		poudriere_rename_ports
1971
	fi
1972
}
1973

    
1974
poudriere_init() {
1975
	local _error=0
1976
	local _archs=$(poudriere_possible_archs)
1977
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
1978

    
1979
	LOGFILE=${BUILDER_LOGS}/poudriere.log
1980

    
1981
	# Sanity checks
1982
	if [ -z "${ZFS_TANK}" ]; then
1983
		echo ">>> ERROR: \$ZFS_TANK is empty" | tee -a ${LOGFILE}
1984
		error=1
1985
	fi
1986

    
1987
	if [ -z "${ZFS_ROOT}" ]; then
1988
		echo ">>> ERROR: \$ZFS_ROOT is empty" | tee -a ${LOGFILE}
1989
		error=1
1990
	fi
1991

    
1992
	if [ -z "${POUDRIERE_PORTS_NAME}" ]; then
1993
		echo ">>> ERROR: \$POUDRIERE_PORTS_NAME is empty" | tee -a ${LOGFILE}
1994
		error=1
1995
	fi
1996

    
1997
	if [ ${_error} -eq 1 ]; then
1998
		print_error_pfS
1999
	fi
2000

    
2001
	# Check if zpool exists
2002
	if ! zpool list ${ZFS_TANK} >/dev/null 2>&1; then
2003
		echo ">>> ERROR: ZFS tank ${ZFS_TANK} not found, please create it and try again..." | tee -a ${LOGFILE}
2004
		print_error_pfS
2005
	fi
2006

    
2007
	# Check if zfs rootfs exists
2008
	if ! zfs list ${ZFS_TANK}${ZFS_ROOT} >/dev/null 2>&1; then
2009
		echo -n ">>> Creating ZFS filesystem ${ZFS_TANK}${ZFS_ROOT}... "
2010
		if zfs create -o atime=off -o mountpoint=/usr/local${ZFS_ROOT} \
2011
		    ${ZFS_TANK}${ZFS_ROOT} >/dev/null 2>&1; then
2012
			echo "Done!"
2013
		else
2014
			echo "Failed!"
2015
			print_error_pfS
2016
		fi
2017
	fi
2018

    
2019
	# Make sure poudriere is installed
2020
	if ! pkg info --quiet poudriere; then
2021
		echo ">>> Installing poudriere..." | tee -a ${LOGFILE}
2022
		if ! pkg install poudriere >/dev/null 2>&1; then
2023
			echo ">>> ERROR: poudriere was not installed, aborting..." | tee -a ${LOGFILE}
2024
			print_error_pfS
2025
		fi
2026
	fi
2027

    
2028
	# Create poudriere.conf
2029
	if [ -z "${POUDRIERE_PORTS_GIT_URL}" ]; then
2030
		echo ">>> ERROR: POUDRIERE_PORTS_GIT_URL is not defined"
2031
		print_error_pfS
2032
	fi
2033
	echo ">>> Creating poudriere.conf" | tee -a ${LOGFILE}
2034
	cat <<EOF >/usr/local/etc/poudriere.conf
2035
ZPOOL=${ZFS_TANK}
2036
ZROOTFS=${ZFS_ROOT}
2037
RESOLV_CONF=/etc/resolv.conf
2038
BASEFS=/usr/local/poudriere
2039
USE_PORTLINT=no
2040
USE_TMPFS=yes
2041
NOLINUX=yes
2042
DISTFILES_CACHE=/usr/ports/distfiles
2043
CHECK_CHANGED_OPTIONS=yes
2044
CHECK_CHANGED_DEPS=yes
2045
ATOMIC_PACKAGE_REPOSITORY=yes
2046
COMMIT_PACKAGES_ON_FAILURE=no
2047
EOF
2048

    
2049
	# Create specific items conf
2050
	[ ! -d /usr/local/etc/poudriere.d ] \
2051
		&& mkdir -p /usr/local/etc/poudriere.d
2052

    
2053
	cat <<EOF >/usr/local/etc/poudriere.d/${POUDRIERE_PORTS_NAME}-poudriere.conf
2054
GIT_URL="${POUDRIERE_PORTS_GIT_URL}"
2055
EOF
2056

    
2057
	# Create DISTFILES_CACHE if it doesn't exist
2058
	if [ ! -d /usr/ports/distfiles ]; then
2059
		mkdir -p /usr/ports/distfiles
2060
	fi
2061

    
2062
	# Remove old jails
2063
	for jail_arch in ${_archs}; do
2064
		jail_name=$(poudriere_jail_name ${jail_arch})
2065

    
2066
		if poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2067
			echo ">>> Poudriere jail ${jail_name} already exists, deleting it..." | tee -a ${LOGFILE}
2068
			poudriere jail -d -j "${jail_name}" >/dev/null 2>&1
2069
		fi
2070
	done
2071

    
2072
	# Remove old ports tree
2073
	if poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
2074
		echo ">>> Poudriere ports tree ${POUDRIERE_PORTS_NAME} already exists, deleting it..." | tee -a ${LOGFILE}
2075
		poudriere ports -d -p "${POUDRIERE_PORTS_NAME}"
2076
	fi
2077

    
2078
	poudriere_create_patch
2079

    
2080
	local native_xtools=""
2081
	# Now we are ready to create jails
2082
	for jail_arch in ${_archs}; do
2083
		jail_name=$(poudriere_jail_name ${jail_arch})
2084

    
2085
		if [ "${jail_arch}" = "arm.armv6" ]; then
2086
			native_xtools="-x"
2087
		else
2088
			native_xtools=""
2089
		fi
2090

    
2091
		echo -n ">>> Creating jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
2092
		# XXX: Change -m to git when it's available in poudriere
2093
		if ! script -aq ${LOGFILE} poudriere jail -c -j "${jail_name}" -v ${FREEBSD_PARENT_BRANCH} \
2094
				-a ${jail_arch} -m svn -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
2095
			echo "" | tee -a ${LOGFILE}
2096
			echo ">>> ERROR: Error creating jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
2097
			print_error_pfS
2098
		fi
2099
		echo "Done!" | tee -a ${LOGFILE}
2100
	done
2101

    
2102
	poudriere_create_ports_tree
2103

    
2104
	echo ">>> Poudriere is now configured!" | tee -a ${LOGFILE}
2105
}
2106

    
2107
poudriere_update_jails() {
2108
	local _archs=$(poudriere_possible_archs)
2109
	local _jail_patch="${SCRATCHDIR}/poudriere_jail.${GIT_REPO_BRANCH_OR_TAG}.patch"
2110

    
2111
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2112

    
2113
	poudriere_create_patch
2114

    
2115
	local native_xtools=""
2116
	for jail_arch in ${_archs}; do
2117
		jail_name=$(poudriere_jail_name ${jail_arch})
2118

    
2119
		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2120
			echo ">>> Poudriere jail ${jail_name} not found, skipping..." | tee -a ${LOGFILE}
2121
			continue
2122
		fi
2123

    
2124
		if [ "${jail_arch}" = "arm.armv6" ]; then
2125
			native_xtools="-x"
2126
		else
2127
			native_xtools=""
2128
		fi
2129

    
2130
		echo -n ">>> Updating jail ${jail_name}, it may take some time... " | tee -a ${LOGFILE}
2131
		if ! script -aq ${LOGFILE} poudriere jail -u -j "${jail_name}" -P ${_jail_patch} ${native_xtools} >/dev/null 2>&1; then
2132
			echo "" | tee -a ${LOGFILE}
2133
			echo ">>> ERROR: Error updating jail ${jail_name}, aborting..." | tee -a ${LOGFILE}
2134
			print_error_pfS
2135
		fi
2136
		echo "Done!" | tee -a ${LOGFILE}
2137
	done
2138
}
2139

    
2140
poudriere_update_ports() {
2141
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2142

    
2143
	# Create ports tree if necessary
2144
	if ! poudriere ports -l | grep -q -E "^${POUDRIERE_PORTS_NAME}[[:blank:]]"; then
2145
		poudriere_create_ports_tree
2146
	else
2147
		echo -n ">>> Resetting local changes on ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
2148
		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" reset --hard >/dev/null 2>&1
2149
		script -aq ${LOGFILE} git -C "/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}" clean -fd >/dev/null 2>&1
2150
		echo "Done!" | tee -a ${LOGFILE}
2151
		echo -n ">>> Updating ports tree ${POUDRIERE_PORTS_NAME}... " | tee -a ${LOGFILE}
2152
		script -aq ${LOGFILE} poudriere ports -u -p "${POUDRIERE_PORTS_NAME}" >/dev/null 2>&1
2153
		echo "Done!" | tee -a ${LOGFILE}
2154
		poudriere_rename_ports
2155
	fi
2156
}
2157

    
2158
poudriere_bulk() {
2159
	local _archs=$(poudriere_possible_archs)
2160

    
2161
	LOGFILE=${BUILDER_LOGS}/poudriere.log
2162

    
2163
	if [ -z "${DO_NOT_UPLOAD}" -a -z "${PKG_RSYNC_HOSTNAME}" ]; then
2164
		echo ">>> ERROR: PKG_RSYNC_HOSTNAME is not set"
2165
		print_error_pfS
2166
	fi
2167

    
2168
	poudriere_create_ports_tree
2169

    
2170
	[ -d /usr/local/etc/poudriere.d ] || \
2171
		mkdir -p /usr/local/etc/poudriere.d
2172

    
2173
	if [ -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" ]; then
2174
		cp -f "${BUILDER_TOOLS}/conf/pfPorts/make.conf" /usr/local/etc/poudriere.d/${POUDRIERE_PORTS_NAME}-make.conf
2175
	fi
2176

    
2177
	# Change version of pfSense meta ports for snapshots
2178
	if [ -z "${_IS_RELEASE}" ]; then
2179
		for meta_pkg in ${PRODUCT_NAME} ${PRODUCT_NAME}-vmware; do
2180
			local _meta_pkg_version="$(echo "${PRODUCT_VERSION}" | sed 's,DEVELOPMENT,ALPHA,')-${DATESTRING}"
2181
			sed -i '' -e "/^DISTVERSION/ s,^.*,DISTVERSION=	${_meta_pkg_version}," \
2182
				/usr/local/poudriere/ports/${POUDRIERE_PORTS_NAME}/security/${meta_pkg}/Makefile
2183
		done
2184
	fi
2185

    
2186
	for jail_arch in ${_archs}; do
2187
		jail_name=$(poudriere_jail_name ${jail_arch})
2188

    
2189
		if ! poudriere jail -i -j "${jail_name}" >/dev/null 2>&1; then
2190
			echo ">>> Poudriere jail ${jail_name} not found, skipping..." | tee -a ${LOGFILE}
2191
			continue
2192
		fi
2193

    
2194
		if [ -f "${POUDRIERE_BULK}.${jail_arch}" ]; then
2195
			_ref_bulk="${POUDRIERE_BULK}.${jail_arch}"
2196
		else
2197
			_ref_bulk="${POUDRIERE_BULK}"
2198
		fi
2199

    
2200
		_bulk=${SCRATCHDIR}/poudriere_bulk.${GIT_REPO_BRANCH_OR_TAG}
2201
		sed -e "s,%%PRODUCT_NAME%%,${PRODUCT_NAME},g" ${_ref_bulk} > ${_bulk}
2202

    
2203
		if ! poudriere bulk -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME}; then
2204
			echo ">>> ERROR: Something went wrong..."
2205
			print_error_pfS
2206
		fi
2207

    
2208
		echo ">>> Cleaning up old packages from repo..."
2209
		if ! poudriere pkgclean -f ${_bulk} -j ${jail_name} -p ${POUDRIERE_PORTS_NAME} -y; then
2210
			echo ">>> ERROR: Something went wrong..."
2211
			print_error_pfS
2212
		fi
2213

    
2214
		# ./ is intentional, it's an rsync trick to make it chdir to directory before sending it
2215
		pkg_repo_rsync "/usr/local/poudriere/data/packages/./${jail_name}-${POUDRIERE_PORTS_NAME}"
2216
	done
2217
}
2218

    
2219
# This routine is called to write out to stdout
2220
# a string. The string is appended to $SNAPSHOTSLOGFILE
2221
# and we scp the log file to the builder host if
2222
# needed for the real time logging functions.
2223
snapshots_update_status() {
2224
	if [ -z "$1" ]; then
2225
		return
2226
	fi
2227
	if [ -z "${SNAPSHOTS}" -a -z "${POUDRIERE_SNAPSHOTS}" ]; then
2228
		return
2229
	fi
2230
	echo "$*"
2231
	echo "`date` -|- $*" >> $SNAPSHOTSLOGFILE
2232
	if [ -z "${DO_NOT_UPLOAD}" -a -n "${SNAPSHOTS_RSYNCIP}" ]; then
2233
		LU=$(cat $SNAPSHOTSLASTUPDATE 2>/dev/null)
2234
		CT=$(date "+%H%M%S")
2235
		# Only update every minute
2236
		if [ "$LU" != "$CT" ]; then
2237
			ssh ${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP} \
2238
				"mkdir -p ${SNAPSHOTS_RSYNCLOGS}"
2239
			scp -q $SNAPSHOTSLOGFILE \
2240
				${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP}:${SNAPSHOTS_RSYNCLOGS}/build.log
2241
			date "+%H%M%S" > $SNAPSHOTSLASTUPDATE
2242
		fi
2243
	fi
2244
}
2245

    
2246
# Copy the current log file to $filename.old on
2247
# the snapshot www server (real time logs)
2248
snapshots_rotate_logfile() {
2249
	if [ -z "${DO_NOT_UPLOAD}" -a -n "${SNAPSHOTS_RSYNCIP}" ]; then
2250
		scp -q $SNAPSHOTSLOGFILE \
2251
			${SNAPSHOTS_RSYNCUSER}@${SNAPSHOTS_RSYNCIP}:${SNAPSHOTS_RSYNCLOGS}/build.log.old
2252
	fi
2253

    
2254
	# Cleanup log file
2255
	rm -f $SNAPSHOTSLOGFILE;    touch $SNAPSHOTSLOGFILE
2256
	rm -f $SNAPSHOTSLASTUPDATE; touch $SNAPSHOTSLASTUPDATE
2257

    
2258
}
2259

    
2260
snapshots_create_latest_symlink() {
2261
	local _image="${1}"
2262

    
2263
	if [ -z "${_image}" ]; then
2264
		return
2265
	fi
2266

    
2267
	if [ -z "${TIMESTAMP_SUFFIX}" ]; then
2268
		return
2269
	fi
2270

    
2271
	if [ -f "${_image}.gz" ]; then
2272
		local _image_fixed="${_image}.gz"
2273
	elif [ -f "${_image}" ]; then
2274
		local _image_fixed=${_image}
2275
	else
2276
		return
2277
	fi
2278

    
2279
	local _symlink=$(echo ${_image_fixed} | sed "s,${TIMESTAMP_SUFFIX},-latest,")
2280
	ln -sf $(basename ${_image_fixed}) ${_symlink}
2281
	ln -sf $(basename ${_image}).sha256 ${_symlink}.sha256
2282
}
2283

    
2284
snapshots_copy_to_staging_nanobsd() {
2285
	for NANOTYPE in nanobsd nanobsd-vga; do
2286
		for FILESIZE in ${1}; do
2287
			FILENAMEFULL="$(nanobsd_image_filename ${FILESIZE} ${NANOTYPE}).gz"
2288
			FILENAMEUPGRADE="$(nanobsd_image_filename ${FILESIZE} ${NANOTYPE} 1).gz"
2289
			mkdir -p $STAGINGAREA/nanobsd
2290
			mkdir -p $STAGINGAREA/nanobsdupdates
2291

    
2292
			cp -l $IMAGES_FINAL_DIR/$FILENAMEFULL $STAGINGAREA/nanobsd/ 2>/dev/null
2293
			cp -l $IMAGES_FINAL_DIR/$FILENAMEUPGRADE $STAGINGAREA/nanobsdupdates 2>/dev/null
2294

    
2295
			if [ -f $STAGINGAREA/nanobsd/$FILENAMEFULL ]; then
2296
				sha256 $STAGINGAREA/nanobsd/$FILENAMEFULL > $STAGINGAREA/nanobsd/$FILENAMEFULL.sha256 2>/dev/null
2297
			fi
2298
			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
2299
				sha256 $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE > $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE.sha256 2>/dev/null
2300
			fi
2301

    
2302
			# Copy NanoBSD auto update:
2303
			if [ -f $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE ]; then
2304
				cp -l $STAGINGAREA/nanobsdupdates/$FILENAMEUPGRADE $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz 2>/dev/null
2305
				sha256 $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz > $STAGINGAREA/latest-${NANOTYPE}-$FILESIZE.img.gz.sha256 2>/dev/null
2306
				# NOTE: Updates need a file with output similar to date output
2307
				# Use the file generated at start of snapshots_dobuilds() to be consistent on times
2308
				cp $BUILTDATESTRINGFILE $STAGINGAREA/version-${NANOTYPE}-$FILESIZE
2309
			fi
2310
		done
2311
	done
2312
}
2313

    
2314
snapshots_copy_to_staging_iso_updates() {
2315
	local _img=""
2316

    
2317
	for _img in ${ISOPATH} ${MEMSTICKPATH} ${MEMSTICKSERIALPATH}; do
2318
		if [ ! -f "${_img}.gz" ]; then
2319
			continue
2320
		fi
2321
		sha256 ${_img}.gz > ${_img}.sha256
2322
		cp -l ${_img}* $STAGINGAREA/ 2>/dev/null
2323
		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${_img})
2324
	done
2325

    
2326
	if [ -f "${UPDATES_TARBALL_FILENAME}" ]; then
2327
		sha256 ${UPDATES_TARBALL_FILENAME} > ${UPDATES_TARBALL_FILENAME}.sha256
2328
		cp -l ${UPDATES_TARBALL_FILENAME}* $STAGINGAREA/ 2>/dev/null
2329
		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${UPDATES_TARBALL_FILENAME})
2330
	fi
2331

    
2332
	if [ "${TARGET}" = "amd64" -a -f "${MEMSTICKADIPATH}.gz" ]; then
2333
		sha256 ${MEMSTICKADIPATH}.gz > ${MEMSTICKADIPATH}.sha256
2334
		cp -l ${MEMSTICKADIPATH}* $STAGINGAREA/ 2>/dev/null
2335
		snapshots_create_latest_symlink ${STAGINGAREA}/$(basename ${MEMSTICKADIPATH})
2336
	fi
2337

    
2338
	# NOTE: Updates need a file with output similar to date output
2339
	# Use the file generated at start of snapshots_dobuilds() to be consistent on times
2340
	if [ -z "${_IS_RELEASE}" ]; then
2341
		cp $BUILTDATESTRINGFILE $STAGINGAREA/version 2>/dev/null
2342
	fi
2343
}
2344

    
2345
snapshots_scp_files() {
2346
	if [ -z "${RSYNC_COPY_ARGUMENTS}" ]; then
2347
		RSYNC_COPY_ARGUMENTS="-ave ssh --timeout=60 --bwlimit=${RSYNCKBYTELIMIT}" #--bwlimit=50
2348
	fi
2349

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

    
2355
	snapshots_update_status ">>> Copying files to ${RSYNCIP}"
2356

    
2357
	# Ensure directory(s) are available
2358
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/installer"
2359
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/updates"
2360
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/nanobsd"
2361
	if [ -d $STAGINGAREA/virtualization ]; then
2362
		ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/virtualization"
2363
	fi
2364
	ssh ${RSYNCUSER}@${RSYNCIP} "mkdir -p ${RSYNCPATH}/.updaters"
2365
	# ensure permissions are correct for r+w
2366
	ssh ${RSYNCUSER}@${RSYNCIP} "chmod -R ug+rw ${RSYNCPATH}/."
2367
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-*iso* \
2368
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/installer/
2369
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-memstick* \
2370
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/installer/
2371
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/${PRODUCT_NAME}${PRODUCT_NAME_SUFFIX}-*Update* \
2372
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
2373
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsd/* \
2374
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/nanobsd/
2375
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/nanobsdupdates/* \
2376
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/updates/
2377
	if [ -d $STAGINGAREA/virtualization ]; then
2378
		rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/virtualization/* \
2379
			${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/virtualization/
2380
	fi
2381

    
2382
	# Rather than copy these twice, use ln to link to the latest one.
2383

    
2384
	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz"
2385
	ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest.tgz.sha256"
2386

    
2387
	LATESTFILENAME=$(basename ${UPDATES_TARBALL_FILENAME})
2388
	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME} \
2389
		${RSYNCPATH}/.updaters/latest.tgz"
2390
	ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${LATESTFILENAME}.sha256 \
2391
		${RSYNCPATH}/.updaters/latest.tgz.sha256"
2392

    
2393
	for i in ${FLASH_SIZE}
2394
	do
2395
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
2396
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
2397
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
2398
		ssh ${RSYNCUSER}@${RSYNCIP} "rm -f ${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
2399

    
2400
		FILENAMEUPGRADE="$(nanobsd_image_filename ${i} nanobsd 1).gz"
2401
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
2402
			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz"
2403
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
2404
			${RSYNCPATH}/.updaters/latest-nanobsd-${i}.img.gz.sha256"
2405

    
2406
		FILENAMEUPGRADE="$(nanobsd_image_filename ${i} nanobsd-vga 1).gz"
2407
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE} \
2408
			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz"
2409
		ssh ${RSYNCUSER}@${RSYNCIP} "ln -s ${RSYNCPATH}/updates/${FILENAMEUPGRADE}.sha256 \
2410
			${RSYNCPATH}/.updaters/latest-nanobsd-vga-${i}.img.gz.sha256"
2411
	done
2412

    
2413
	rsync $RSYNC_COPY_ARGUMENTS $STAGINGAREA/version* \
2414
		${RSYNCUSER}@${RSYNCIP}:${RSYNCPATH}/.updaters
2415
	snapshots_update_status ">>> Finished copying files."
2416
}
(2-2/3)