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