mkarchiso 14.2 KB
Newer Older
1
#!/bin/bash
2

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
set -e -u

app_name=${0##*/}
arch=$(uname -m)
pkg_list=""
quiet="y"
pacman_conf="/etc/pacman.conf"
export iso_label="ARCH_$(date +%Y%m)"
iso_publisher="Arch Linux <http://www.archlinux.org>"
iso_application="Arch Linux Live/Rescue CD"
install_dir="arch"

# Show an INFO message
# $1: message string
_msg_info() {
    local _msg="${1}"
    echo "[mkarchiso] INFO: ${_msg}"
}

# Show an ERROR message then exit with status
# $1: message string
# $2: exit code number (with 0 does not exit)
_msg_error() {
    local _msg="${1}"
    local _error=${2}
    echo
    echo "[mkarchiso] ERROR: ${_msg}"
    echo
    if [[ ${_error} -gt 0 ]]; then
        exit ${_error}
    fi
}

# Show space usage similar to df, but better formatted.
# $1: mount-point or mounted device.
_show_space_usage () {
    local _where="${1}"
    local _fs _total _used _avail _pct_u=0 _mnt
    read _fs _total _used _avail _pct_u _mnt < <(df -m "${_where}" | tail -1) &> /dev/null
    _msg_info "Total: ${_total} MiB (100%) | Used: ${_used} MiB (${_pct_u}) | Avail: ${_avail} MiB ($((100 - ${_pct_u%\%}))%)"
}

# Mount a filesystem (trap signals in case of error for unmounting it
# $1: source image
# $2: mount-point
_mount_fs() {
    local _src="${1}"
    local _dst="${2}"
    trap "_umount_fs ${_src}" EXIT HUP INT TERM
    mkdir -p "${_dst}"
    _msg_info "Mounting '${_src}' on '${_dst}'"
    mount "${_src}" "${_dst}"
    _show_space_usage "${_dst}"
}

# Unmount a filesystem (and untrap signals)
# $1: mount-point or device/image
_umount_fs() {
    local _dst="${1}"
    _show_space_usage "${_dst}"
    _msg_info "Unmounting '${_dst}'"
    umount "${_dst}"
    rmdir "${_dst}"
    trap - EXIT HUP INT TERM
}

# Compare if a file/directory (source) is newer than other file (target)
# $1: source file/directory
# $2: target file
# return: 0 if target does not exists or if target is older than source.
#         1 if target is newer than source
_is_directory_changed() {
    local _src="${1}"
    local _dst="${2}"

    if [ -e "${_dst}" ]; then
        if [[ $(find ${_src} -newer ${_dst} | wc -l) -gt 0 ]]; then
            _msg_info "Target '${_dst}' is older than '${_src}', updating."
            rm -f "${_dst}"
            return 0
        else
            _msg_info "Target '${_dst}' is up to date with '${_src}', skipping."
            return 1
        fi
    else
        _msg_info "Target '${_dst}' does not exist, making it from '${_src}'"
        return 0
    fi
}

# Show help usage, with an exit status.
# $1: exit status number.
_usage ()
96
{
97
    echo "usage ${app_name} [options] command <command options>"
98
    echo " general options:"
99
100
    echo "    -p PACKAGE(S)    Package(s) to install, can be used multiple times"
    echo "    -C <file>        Config file for pacman. Default ${pacman_conf}"
101
102
103
    echo "    -L <label>       Set a label for the disk"
    echo "    -P <publisher>   Set a publisher for the disk"
    echo "    -A <application> Set an application name for the disk"
104
105
    echo "    -D <install_dir> Set an install_dir. All files will by located here."
    echo "                     Default ${install_dir}"
106
    echo "                     NOTE: Max 8 characters, use only [a-z0-9]"
107
108
    echo "    -v               Enable verbose output"
    echo "    -h               This message"
109
    echo " commands:"
110
111
112
    echo "   create <dir>"
    echo "      create a base directory layout to work with"
    echo "      includes all specified packages"
113
114
    echo "   prepare <dir>"
    echo "      build all images"
115
    echo "   iso <dir> <image name>"
116
    echo "      build an iso image from the working dir"
117
    exit ${1}
118
119
}

120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# Shows configuration according to command mode.
# $1: create | prepare | iso
_show_config () {
    local _mode="$1"
    echo
    _msg_info "Configuration settings"
    _msg_info "                  Command:   ${command_name}"
    _msg_info "             Architecture:   ${arch}"
    _msg_info "        Working directory:   ${work_dir}"
    _msg_info "   Installation directory:   ${install_dir}"
    case "${_mode}" in
        create)
            _msg_info "       Pacman config file:   ${pacman_conf}"
            _msg_info "                 Packages:   ${pkg_list}"
            ;;
        prepare)
            ;;
        iso)
            _msg_info "               Image name:   ${img_name}"
            _msg_info "               Disk label:   ${iso_label}"
            _msg_info "           Disk publisher:   ${iso_publisher}"
            _msg_info "         Disk application:   ${iso_application}"
            ;;
143
    esac
144
145
    echo
}
146

147
# Install desired packages to root-image
148
149
_pacman ()
{
150
151
152
153
    _msg_info "Installing packages to '${work_dir}/root-image/'"

    if [[ "${quiet}" = "y" ]]; then
        mkarchroot -n -C "${pacman_conf}" -f "${work_dir}/root-image" $* &> /dev/null
154
    else
155
        mkarchroot -n -C "${pacman_conf}" -f "${work_dir}/root-image" $*
156
    fi
157
158

    # Cleanup
159
    find "${work_dir}" -name "*.pacnew" -name "*.pacsave" -name "*.pacorig" -delete
160
161
}

162
163
164
165
166
167
168
169
170
# Cleanup root-image
_cleanup () {
    _msg_info "Cleaning up what we can on root-image"
    # remove the initcpio images that were generated for the host system
    if [[ -d "${work_dir}/root-image/boot" ]]; then 
        find "${work_dir}/root-image/boot" -name '*.img' -delete
    fi
    # Delete pacman database sync cache files (*.tar.gz)
    if [[ -d "${work_dir}/root-image/var/lib/pacman" ]]; then
171
        find "${work_dir}/root-image/var/lib/pacman" -maxdepth 1 -type f -delete
172
173
174
    fi
    # Delete pacman database sync cache
    if [[ -d "${work_dir}/root-image/var/lib/pacman/sync" ]]; then
175
        find "${work_dir}/root-image/var/lib/pacman/sync" -delete
176
177
178
    fi
    # Delete pacman package cache
    if [[ -d "${work_dir}/root-image/var/cache/pacman/pkg" ]]; then
179
        find "${work_dir}/root-image/var/cache/pacman/pkg" -type f -delete
180
181
182
    fi
    # Delete all log files, keeps empty dirs.
    if [[ -d "${work_dir}/root-image/var/log" ]]; then
183
        find "${work_dir}/root-image/var/log" -type f -delete
184
185
186
    fi
    # Delete all temporary files and dirs
    if [[ -d "${work_dir}/root-image/var/tmp" ]]; then
187
        find "${work_dir}/root-image/var/tmp" -mindepth 1 -delete
188
189
190
    fi
    # Delete all temporary files and dirs
    if [[ -d "${work_dir}/root-image/tmp" ]]; then
191
        find "${work_dir}/root-image/tmp" -mindepth 1 -delete
192
    fi
193
}
194

195
196
197
198
199
200
# Makes a SquashFS filesystem image of file/directory passes as argument with desired compression.
# $1: Source file/directory
# $2: SquashFS compression type (gzip | lzo | xz)
_mksfs () {
    local _src="${1}"
    local _sfs_comp="${2}"
201

202
203
    if [[ ! -e "${work_dir}/${_src}" ]]; then
        _msg_error "The path '${work_dir}/${_src}' does not exist" 1
204
205
    fi

206
207
208
209
210
211
    local _sfs_img="${work_dir}/${_src}.sfs"

    _msg_info "Creating SquashFS image for '${work_dir}/${_src}', This may take some time..."
    local _seconds=${SECONDS}
    if [[ "${quiet}" = "y" ]]; then
        mksquashfs "${work_dir}/${_src}" "${_sfs_img}" -noappend -comp "${_sfs_comp}" &> /dev/null
212
    else
213
        mksquashfs "${work_dir}/${_src}" "${_sfs_img}" -noappend -comp "${_sfs_comp}"
214
    fi
215
216
    _seconds=$((SECONDS - _seconds))
    printf "[mkarchiso] INFO: Image creation done in %02d:%02d minutes\n" $((_seconds / 60)) $((_seconds % 60))
217
}
218

219
220
221
222
223
224
225
226
# Makes a filesystem from a source directory.
# $1: Source directory
# $2: Target filesystem type (ext4 | ext3 | ext2 | xfs)
# $3: Size of target filesystem. Can be an absolute value in MiB, or relative value of desired free space (1% - 99%)
_mkfs () {
    local _src="${1}"
    local _fs_type="${2}"
    local _fs_size="${3}"
227

228
229
    local _fs_src="${work_dir}/${_src}"
    local _fs_img="${work_dir}/${_src}.fs"
230

231
232
    if [[ ! -e "${_fs_src}" ]]; then
        _msg_error "The path '${_fs_src}' does not exist" 1
233
234
    fi

235
236
    local _spc_used
    _spc_used=$(du -sxm "${_fs_src}" | awk '{print $1}')
237

238
239
240
241
242
243
244
245
246
247
    # Caculate FS size with desired % of free space, adds 10% overhead to used space.
    if [[ ${_fs_size} != ${_fs_size%\%} ]]; then
        if [[ ${_fs_size%\%} -le 0 || ${_fs_size%\%} -ge 100 ]]; then
            _msg_error "Invalid percentage of free space specified '${_fs_size}' on '${_src}', should be 0% < x < 100%" 1
        fi
        _fs_size=$((_spc_used * 110 / (100 - ${_fs_size%\%})))
    else
        local _spc_used_over=$((_spc_used * 11 / 10))
        if [[ ${_fs_size} -lt ${_spc_used_over} ]]; then
            _msg_error "Filesystem size specified '${_fs_size}' MiB for '${_src}' is too small, must be at least '${_spc_used_over}' MiB" 1
248
249
250
        fi
    fi

251
252
253
254
255
    _msg_info "Creating ${_fs_type} image of ${_fs_size} MiB"
    dd of="${_fs_img}" count=0 bs=1M seek=${_fs_size} &> /dev/null
    local _qflag=""
    if [[ ${quiet} == "y" ]]; then
        _qflag="-q"
256
    fi
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
    case "${_fs_type}" in
        ext4)
            mkfs.ext4 ${_qflag} -O ^has_journal -m 0 -F "${_fs_img}"
            tune2fs -c 0 -i 0 "${_fs_img}" &> /dev/null
            ;;
        ext3)
            mkfs.ext3 ${_qflag} -m 0 -F "${_fs_img}"
            tune2fs -c 0 -i 0 "${_fs_img}" &> /dev/null
            ;;
        ext2)
            mkfs.ext2 ${_qflag} -m 0 -F "${_fs_img}"
            tune2fs -c 0 -i 0 "${_fs_img}" &> /dev/null
            ;;
        xfs)
            mkfs.xfs ${_qflag} "${_fs_img}"
            ;;
        *)
            _msg_error "Invalid filesystem: ${_fs_type}" 1
            ;;
    esac
    _mount_fs "${_fs_img}" "${work_dir}/mnt/${_src}"
    _msg_info "Copying '${_fs_src}/' to '${work_dir}/mnt/${_src}/'"
    rsync -aH "${_fs_src}/" "${work_dir}/mnt/${_src}/"
    _umount_fs "${work_dir}/mnt/${_src}"
281
282
}

283
# Create an ISO9660 filesystem from "iso" directory.
284
command_iso () {
285
286
287
288
289
290
291
    if [[ ! -f "${work_dir}/iso/isolinux/isolinux.bin" ]]; then
         _msg_error "The file '${work_dir}/iso/isolinux/isolinux.bin' does not exist." 1
    fi

    _show_config iso

    _is_directory_changed "${work_dir}/iso" "${img_name}"
Aaron Griffin's avatar
Aaron Griffin committed
292

293
294
295
296
297
298
299
    _msg_info "Creating ISO image..."
    local _qflag=""
    if [[ ${quiet} == "y" ]]; then
        _qflag="-quiet"
    fi
    mkisofs ${_qflag} -r -l \
        -b isolinux/isolinux.bin -c isolinux/boot.cat \
300
        -uid 0 -gid 0 \
301
        -udf -allow-limited-size -iso-level 3 \
302
303
        -input-charset utf-8 -p "prepared by mkarchiso" \
        -no-emul-boot -boot-load-size 4 -boot-info-table \
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
        -publisher "${iso_publisher}" \
        -A "${iso_application}" \
        -V "${iso_label}" \
        -o "${img_name}" "${work_dir}/iso/"
    isohybrid "${img_name}"
    _msg_info "Done! | $(ls -sh ${img_name})"
}

# Parse aitab and create each filesystem specified on that, and push it in "iso" directory.
command_prepare () {
    if [[ ! -f "${work_dir}/iso/${install_dir}/aitab" ]]; then
         _msg_error "The file '${work_dir}/iso/${install_dir}/aitab' does not exist." 1
    fi
    _show_config prepare

    _cleanup
    local _aitab_img _aitab_mnt _aitab_arch _aitab_sfs_comp _aitab_fs_type _aitab_fs_size
    while read _aitab_img _aitab_mnt _aitab_arch _aitab_sfs_comp _aitab_fs_type _aitab_fs_size ; do
        if [[ ${_aitab_img} =~ ^# ]]; then
            continue
        fi
        if [[ ${_aitab_sfs_comp} == "none" && ${_aitab_fs_type} == "none" ]]; then
            _msg_error "In aitab, both fields 'sfs_comp' and 'fs_type' are set to none for '${_aitab_img}' image" 1
        fi
        local _src="${work_dir}/${_aitab_img}"
        local _dst="${work_dir}/iso/${install_dir}/${_aitab_arch}"
        mkdir -p "${_dst}"
        if [[ ${_aitab_fs_type} != "none" ]]; then
            if [[ ${_aitab_sfs_comp} != "none" ]]; then
                if _is_directory_changed "${_src}" "${_dst}/${_aitab_img}.fs.sfs"; then
                    _mkfs ${_aitab_img} ${_aitab_fs_type} ${_aitab_fs_size}
                    _mksfs ${_aitab_img}.fs ${_aitab_sfs_comp}
                    mv "${_src}.fs.sfs" "${_dst}"
                    rm "${_src}.fs"
                fi
            else
                if _is_directory_changed "${_src}" "${_dst}/${_aitab_img}.fs"; then
                    _mkfs ${_aitab_img} ${_aitab_fs_type} ${_aitab_fs_size}
                    mv "${work_dir}/${_aitab_img}.fs" "${_dst}"
                fi
            fi
        else
            if _is_directory_changed "${_src}" "${_dst}/${_aitab_img}.sfs"; then
                _mksfs ${_aitab_img} ${_aitab_sfs_comp}
                mv "${work_dir}/${_aitab_img}.sfs" "${_dst}"
            fi
        fi
    done < "${work_dir}/iso/${install_dir}/aitab"
}

# Install packages on root-image.
# A basic check to avoid double execution/reinstallation is done via hashing package names.
command_create () {
    if [[ ! -f "${pacman_conf}" ]]; then
        _msg_error "Pacman config file '${pacman_conf}' does not exist" 1
    fi

    #trim spaces
    pkg_list="$(echo ${pkg_list})"

    if [[ -z ${pkg_list} ]]; then
        _msg_error "Packages must be specified" 0
        _usage 1
    fi

    _show_config create

    local _pkg_list_hash
    _pkg_list_hash=$(echo ${pkg_list} | sort -u | md5sum | cut -c1-32)
    if [[ -f "${work_dir}/create.${_pkg_list_hash}" ]]; then
        _msg_info "These packages are already installed, skipping."
    else
        mkdir -p "${work_dir}/root-image/"
        : > "${work_dir}/create.${_pkg_list_hash}"
        _pacman "${pkg_list}"
    fi
380
381
}

382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408

if [[ ${EUID} -ne 0 ]]; then
    _msg_error "This script must be run as root." 1
fi

while getopts 'p:C:L:P:A:D:fvh' arg; do
    case "${arg}" in
        p) pkg_list="${pkg_list} ${OPTARG}" ;;
        C) pacman_conf="${OPTARG}" ;;
        L) iso_label="${OPTARG}" ;;
        P) iso_publisher="${OPTARG}" ;;
        A) iso_application="${OPTARG}" ;;
        D) install_dir="${OPTARG}" ;;
        v) quiet="n" ;;
        h|?) _usage 0 ;;
        *)
            _msg_error "Invalid argument '${arg}'" 0
            _usage 1
            ;;
    esac
done

shift $((OPTIND - 1))

if [[ $# -lt 1 ]]; then
    _msg_error "No command specified" 0
    _usage 1
409
fi
410
411
412
413
414
command_name="${1}"

if [[ $# -lt 2 ]]; then
    _msg_error "No working directory specified" 0
    _usage 1
415
fi
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
work_dir="${2}"

case "${command_name}" in
    create)
        command_create
        ;;
    prepare)
        command_prepare
        ;;
    iso)
        if [[ $# -lt 3 ]]; then
            _msg_error "No image specified" 0
            _usage 1
        fi
        img_name="${3}"
        command_iso
        ;;
    *)
        _msg_error "Invalid command name '${command_name}'" 0
        _usage 1
        ;;
esac
438
439

# vim:ts=4:sw=4:et: