Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(986)

Side by Side Diff: build/install-chroot.sh

Issue 2101243005: Add a snapshot of flutter/engine/src/build to our sdk (Closed) Base URL: git@github.com:dart-lang/sdk.git@master
Patch Set: add README.dart Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « build/install-build-deps-android.sh ('k') | build/internal/README.chromium » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 #!/bin/bash -e
2
3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
4 # Use of this source code is governed by a BSD-style license that can be
5 # found in the LICENSE file.
6
7 # This script installs Debian-derived distributions in a chroot environment.
8 # It can for example be used to have an accurate 32bit build and test
9 # environment when otherwise working on a 64bit machine.
10 # N. B. it is unlikely that this script will ever work on anything other than a
11 # Debian-derived system.
12
13 # Older Debian based systems had both "admin" and "adm" groups, with "admin"
14 # apparently being used in more places. Newer distributions have standardized
15 # on just the "adm" group. Check /etc/group for the preferred name of the
16 # administrator group.
17 admin=$(grep '^admin:' /etc/group >&/dev/null && echo admin || echo adm)
18
19 usage() {
20 echo "usage: ${0##*/} [-m mirror] [-g group,...] [-s] [-c]"
21 echo "-b dir additional directories that should be bind mounted,"
22 echo ' or "NONE".'
23 echo " Default: if local filesystems present, ask user for help"
24 echo "-g group,... groups that can use the chroot unauthenticated"
25 echo " Default: '${admin}' and current user's group ('$(id -gn)')"
26 echo "-l List all installed chroot environments"
27 echo "-m mirror an alternate repository mirror for package downloads"
28 echo "-s configure default deb-srcs"
29 echo "-c always copy 64bit helper binaries to 32bit chroot"
30 echo "-h this help message"
31 }
32
33 process_opts() {
34 local OPTNAME OPTIND OPTERR OPTARG
35 while getopts ":b:g:lm:sch" OPTNAME; do
36 case "$OPTNAME" in
37 b)
38 if [ "${OPTARG}" = "NONE" -a -z "${bind_mounts}" ]; then
39 bind_mounts="${OPTARG}"
40 else
41 if [ "${bind_mounts}" = "NONE" -o "${OPTARG}" = "${OPTARG#/}" -o \
42 ! -d "${OPTARG}" ]; then
43 echo "Invalid -b option(s)"
44 usage
45 exit 1
46 fi
47 bind_mounts="${bind_mounts}
48 ${OPTARG} ${OPTARG} none rw,bind 0 0"
49 fi
50 ;;
51 g)
52 [ -n "${OPTARG}" ] &&
53 chroot_groups="${chroot_groups}${chroot_groups:+,}${OPTARG}"
54 ;;
55 l)
56 list_all_chroots
57 exit
58 ;;
59 m)
60 if [ -n "${mirror}" ]; then
61 echo "You can only specify exactly one mirror location"
62 usage
63 exit 1
64 fi
65 mirror="$OPTARG"
66 ;;
67 s)
68 add_srcs="y"
69 ;;
70 c)
71 copy_64="y"
72 ;;
73 h)
74 usage
75 exit 0
76 ;;
77 \:)
78 echo "'-$OPTARG' needs an argument."
79 usage
80 exit 1
81 ;;
82 *)
83 echo "invalid command-line option: $OPTARG"
84 usage
85 exit 1
86 ;;
87 esac
88 done
89
90 if [ $# -ge ${OPTIND} ]; then
91 eval echo "Unexpected command line argument: \${${OPTIND}}"
92 usage
93 exit 1
94 fi
95 }
96
97 list_all_chroots() {
98 for i in /var/lib/chroot/*; do
99 i="${i##*/}"
100 [ "${i}" = "*" ] && continue
101 [ -x "/usr/local/bin/${i%bit}" ] || continue
102 grep -qs "^\[${i%bit}\]\$" /etc/schroot/schroot.conf || continue
103 [ -r "/etc/schroot/script-${i}" -a \
104 -r "/etc/schroot/mount-${i}" ] || continue
105 echo "${i%bit}"
106 done
107 }
108
109 getkey() {
110 (
111 trap 'stty echo -iuclc icanon 2>/dev/null' EXIT INT TERM QUIT HUP
112 stty -echo iuclc -icanon 2>/dev/null
113 dd count=1 bs=1 2>/dev/null
114 )
115 }
116
117 chr() {
118 printf "\\$(printf '%03o' "$1")"
119 }
120
121 ord() {
122 printf '%d' $(printf '%c' "$1" | od -tu1 -An)
123 }
124
125 is_network_drive() {
126 stat -c %T -f "$1/" 2>/dev/null |
127 egrep -qs '^nfs|cifs|smbfs'
128 }
129
130 # Check that we are running as a regular user
131 [ "$(id -nu)" = root ] && {
132 echo "Run this script as a regular user and provide your \"sudo\"" \
133 "password if requested" >&2
134 exit 1
135 }
136
137 process_opts "$@"
138
139 echo "This script will help you through the process of installing a"
140 echo "Debian or Ubuntu distribution in a chroot environment. You will"
141 echo "have to provide your \"sudo\" password when requested."
142 echo
143
144 # Error handler
145 trap 'exit 1' INT TERM QUIT HUP
146 trap 'sudo apt-get clean; tput bel; echo; echo Failed' EXIT
147
148 # Install any missing applications that this script relies on. If these packages
149 # are already installed, don't force another "apt-get install". That would
150 # prevent them from being auto-removed, if they ever become eligible for that.
151 # And as this script only needs the packages once, there is no good reason to
152 # introduce a hard dependency on things such as dchroot and debootstrap.
153 dep=
154 for i in dchroot debootstrap libwww-perl; do
155 [ -d /usr/share/doc/"$i" ] || dep="$dep $i"
156 done
157 [ -n "$dep" ] && sudo apt-get -y install $dep
158 sudo apt-get -y install schroot
159
160 # Create directory for chroot
161 sudo mkdir -p /var/lib/chroot
162
163 # Find chroot environments that can be installed with debootstrap
164 targets="$(cd /usr/share/debootstrap/scripts
165 ls | grep '^[a-z]*$')"
166
167 # Ask user to pick one of the available targets
168 echo "The following targets are available to be installed in a chroot:"
169 j=1; for i in $targets; do
170 printf '%4d: %s\n' "$j" "$i"
171 j=$(($j+1))
172 done
173 while :; do
174 printf "Which target would you like to install: "
175 read n
176 [ "$n" -gt 0 -a "$n" -lt "$j" ] >&/dev/null && break
177 done
178 j=1; for i in $targets; do
179 [ "$j" -eq "$n" ] && { distname="$i"; break; }
180 j=$(($j+1))
181 done
182 echo
183
184 # On x86-64, ask whether the user wants to install x86-32 or x86-64
185 archflag=
186 arch=
187 if [ "$(uname -m)" = x86_64 ]; then
188 while :; do
189 echo "You are running a 64bit kernel. This allows you to install either a"
190 printf "32bit or a 64bit chroot environment. %s" \
191 "Which one do you want (32, 64) "
192 read arch
193 [ "${arch}" == 32 -o "${arch}" == 64 ] && break
194 done
195 [ "${arch}" == 32 ] && archflag="--arch i386" || archflag="--arch amd64"
196 arch="${arch}bit"
197 echo
198 fi
199 target="${distname}${arch}"
200
201 # Don't accidentally overwrite an existing installation
202 [ -d /var/lib/chroot/"${target}" ] && {
203 while :; do
204 echo "This chroot already exists on your machine."
205 if schroot -l --all-sessions 2>&1 |
206 sed 's/^session://' |
207 grep -qs "^${target%bit}-"; then
208 echo "And it appears to be in active use. Terminate all programs that"
209 echo "are currently using the chroot environment and then re-run this"
210 echo "script."
211 echo "If you still get an error message, you might have stale mounts"
212 echo "that you forgot to delete. You can always clean up mounts by"
213 echo "executing \"${target%bit} -c\"."
214 exit 1
215 fi
216 echo "I can abort installation, I can overwrite the existing chroot,"
217 echo "or I can delete the old one and then exit. What would you like to"
218 printf "do (a/o/d)? "
219 read choice
220 case "${choice}" in
221 a|A) exit 1;;
222 o|O) sudo rm -rf "/var/lib/chroot/${target}"; break;;
223 d|D) sudo rm -rf "/var/lib/chroot/${target}" \
224 "/usr/local/bin/${target%bit}" \
225 "/etc/schroot/mount-${target}" \
226 "/etc/schroot/script-${target}" \
227 "/etc/schroot/${target}"
228 sudo sed -ni '/^[[]'"${target%bit}"']$/,${
229 :1;n;/^[[]/b2;b1;:2;p;n;b2};p' \
230 "/etc/schroot/schroot.conf"
231 trap '' INT TERM QUIT HUP
232 trap '' EXIT
233 echo "Deleted!"
234 exit 0;;
235 esac
236 done
237 echo
238 }
239 sudo mkdir -p /var/lib/chroot/"${target}"
240
241 # Offer to include additional standard repositories for Ubuntu-based chroots.
242 alt_repos=
243 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" && {
244 while :; do
245 echo "Would you like to add ${distname}-updates and ${distname}-security "
246 printf "to the chroot's sources.list (y/n)? "
247 read alt_repos
248 case "${alt_repos}" in
249 y|Y)
250 alt_repos="y"
251 break
252 ;;
253 n|N)
254 break
255 ;;
256 esac
257 done
258 echo
259 }
260
261 # Check for non-standard file system mount points and ask the user whether
262 # they should be imported into the chroot environment
263 # We limit to the first 26 mount points that much some basic heuristics,
264 # because a) that allows us to enumerate choices with a single character,
265 # and b) if we find more than 26 mount points, then these are probably
266 # false-positives and something is very unusual about the system's
267 # configuration. No need to spam the user with even more information that
268 # is likely completely irrelevant.
269 if [ -z "${bind_mounts}" ]; then
270 mounts="$(awk '$2 != "/" && $2 !~ "^/boot" && $2 !~ "^/home" &&
271 $2 !~ "^/media" && $2 !~ "^/run" &&
272 ($3 ~ "ext[2-4]" || $3 == "reiserfs" || $3 == "btrfs" ||
273 $3 == "xfs" || $3 == "jfs" || $3 == "u?msdos" ||
274 $3 == "v?fat" || $3 == "hfs" || $3 == "ntfs" ||
275 $3 ~ "nfs[4-9]?" || $3 == "smbfs" || $3 == "cifs") {
276 print $2
277 }' /proc/mounts |
278 head -n26)"
279 if [ -n "${mounts}" ]; then
280 echo "You appear to have non-standard mount points that you"
281 echo "might want to import into the chroot environment:"
282 echo
283 sel=
284 while :; do
285 # Print a menu, listing all non-default mounts of local or network
286 # file systems.
287 j=1; for m in ${mounts}; do
288 c="$(printf $(printf '\\%03o' $((64+$j))))"
289 echo "$sel" | grep -qs $c &&
290 state="mounted in chroot" || state="$(tput el)"
291 printf " $c) %-40s${state}\n" "$m"
292 j=$(($j+1))
293 done
294 # Allow user to interactively (de-)select any of the entries
295 echo
296 printf "Select mount points that you want to be included or press %s" \
297 "SPACE to continue"
298 c="$(getkey | tr a-z A-Z)"
299 [ "$c" == " " ] && { echo; echo; break; }
300 if [ -z "$c" ] ||
301 [ "$c" '<' 'A' -o $(ord "$c") -gt $((64 + $(ord "$j"))) ]; then
302 # Invalid input, ring the console bell
303 tput bel
304 else
305 # Toggle the selection for the given entry
306 if echo "$sel" | grep -qs $c; then
307 sel="$(printf "$sel" | sed "s/$c//")"
308 else
309 sel="$sel$c"
310 fi
311 fi
312 # Reposition cursor to the top of the list of entries
313 tput cuu $(($j + 1))
314 echo
315 done
316 fi
317 j=1; for m in ${mounts}; do
318 c="$(chr $(($j + 64)))"
319 if echo "$sel" | grep -qs $c; then
320 bind_mounts="${bind_mounts}$m $m none rw,bind 0 0
321 "
322 fi
323 j=$(($j+1))
324 done
325 fi
326
327 # Remove stale entry from /etc/schroot/schroot.conf. Entries start
328 # with the target name in square brackets, followed by an arbitrary
329 # number of lines. The entry stops when either the end of file has
330 # been reached, or when the beginning of a new target is encountered.
331 # This means, we cannot easily match for a range of lines in
332 # "sed". Instead, we actually have to iterate over each line and check
333 # whether it is the beginning of a new entry.
334 sudo sed -ni '/^[[]'"${target%bit}"']$/,${:1;n;/^[[]/b2;b1;:2;p;n;b2};p' \
335 /etc/schroot/schroot.conf
336
337 # Download base system. This takes some time
338 if [ -z "${mirror}" ]; then
339 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" &&
340 mirror="http://archive.ubuntu.com/ubuntu" ||
341 mirror="http://ftp.us.debian.org/debian"
342 fi
343
344 sudo ${http_proxy:+http_proxy="${http_proxy}"} debootstrap ${archflag} \
345 "${distname}" "/var/lib/chroot/${target}" "$mirror"
346
347 # Add new entry to /etc/schroot/schroot.conf
348 grep -qs ubuntu.com /usr/share/debootstrap/scripts/"${distname}" &&
349 brand="Ubuntu" || brand="Debian"
350 if [ -z "${chroot_groups}" ]; then
351 chroot_groups="${admin},$(id -gn)"
352 fi
353
354 if [ -d '/etc/schroot/default' ]; then
355 new_version=1
356 fstab="/etc/schroot/${target}/fstab"
357 else
358 new_version=0
359 fstab="/etc/schroot/mount-${target}"
360 fi
361
362 if [ "$new_version" = "1" ]; then
363 sudo cp -ar /etc/schroot/default /etc/schroot/${target}
364
365 sudo sh -c 'cat >>/etc/schroot/schroot.conf' <<EOF
366 [${target%bit}]
367 description=${brand} ${distname} ${arch}
368 type=directory
369 directory=/var/lib/chroot/${target}
370 users=root
371 groups=${chroot_groups}
372 root-groups=${chroot_groups}
373 personality=linux$([ "${arch}" != 64bit ] && echo 32)
374 profile=${target}
375
376 EOF
377 [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] &&
378 printf "${bind_mounts}" |
379 sudo sh -c "cat >>${fstab}"
380 else
381 # Older versions of schroot wanted a "priority=" line, whereas recent
382 # versions deprecate "priority=" and warn if they see it. We don't have
383 # a good feature test, but scanning for the string "priority=" in the
384 # existing "schroot.conf" file is a good indication of what to do.
385 priority=$(grep -qs 'priority=' /etc/schroot/schroot.conf &&
386 echo 'priority=3' || :)
387 sudo sh -c 'cat >>/etc/schroot/schroot.conf' <<EOF
388 [${target%bit}]
389 description=${brand} ${distname} ${arch}
390 type=directory
391 directory=/var/lib/chroot/${target}
392 users=root
393 groups=${chroot_groups}
394 root-groups=${chroot_groups}
395 personality=linux$([ "${arch}" != 64bit ] && echo 32)
396 script-config=script-${target}
397 ${priority}
398
399 EOF
400
401 # Set up a list of mount points that is specific to this
402 # chroot environment.
403 sed '/^FSTAB=/s,"[^"]*","'"${fstab}"'",' \
404 /etc/schroot/script-defaults |
405 sudo sh -c 'cat >/etc/schroot/script-'"${target}"
406 sed '\,^/home[/[:space:]],s/\([,[:space:]]\)bind[[:space:]]/\1rbind /' \
407 /etc/schroot/mount-defaults |
408 sudo sh -c "cat > ${fstab}"
409 fi
410
411 # Add the extra mount points that the user told us about
412 [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] &&
413 printf "${bind_mounts}" |
414 sudo sh -c 'cat >>'"${fstab}"
415
416 # If this system has a "/media" mountpoint, import it into the chroot
417 # environment. Most modern distributions use this mount point to
418 # automatically mount devices such as CDROMs, USB sticks, etc...
419 if [ -d /media ] &&
420 ! grep -qs '^/media' "${fstab}"; then
421 echo '/media /media none rw,rbind 0 0' |
422 sudo sh -c 'cat >>'"${fstab}"
423 fi
424
425 # Share /dev/shm, /run and /run/shm.
426 grep -qs '^/dev/shm' "${fstab}" ||
427 echo '/dev/shm /dev/shm none rw,bind 0 0' |
428 sudo sh -c 'cat >>'"${fstab}"
429 if [ ! -d "/var/lib/chroot/${target}/run" ] &&
430 ! grep -qs '^/run' "${fstab}"; then
431 echo '/run /run none rw,bind 0 0' |
432 sudo sh -c 'cat >>'"${fstab}"
433 fi
434 if ! grep -qs '^/run/shm' "${fstab}"; then
435 { [ -d /run ] && echo '/run/shm /run/shm none rw,bind 0 0' ||
436 echo '/dev/shm /run/shm none rw,bind 0 0'; } |
437 sudo sh -c 'cat >>'"${fstab}"
438 fi
439
440 # Set up a special directory that changes contents depending on the target
441 # that is executing.
442 d="$(readlink -f "${HOME}/chroot" 2>/dev/null || echo "${HOME}/chroot")"
443 s="${d}/.${target}"
444 echo "${s} ${d} none rw,bind 0 0" |
445 sudo sh -c 'cat >>'"${target}"
446 mkdir -p "${s}"
447
448 # Install a helper script to launch commands in the chroot
449 sudo sh -c 'cat >/usr/local/bin/'"${target%bit}" <<'EOF'
450 #!/bin/bash
451
452 chroot="${0##*/}"
453
454 wrap() {
455 # Word-wrap the text passed-in on stdin. Optionally, on continuation lines
456 # insert the same number of spaces as the number of characters in the
457 # parameter(s) passed to this function.
458 # If the "fold" program cannot be found, or if the actual width of the
459 # terminal cannot be determined, this function doesn't attempt to do any
460 # wrapping.
461 local f="$(type -P fold)"
462 [ -z "${f}" ] && { cat; return; }
463 local c="$(stty -a </dev/tty 2>/dev/null |
464 sed 's/.*columns[[:space:]]*\([0-9]*\).*/\1/;t;d')"
465 [ -z "${c}" ] && { cat; return; }
466 local i="$(echo "$*"|sed 's/./ /g')"
467 local j="$(printf %s "${i}"|wc -c)"
468 if [ "${c}" -gt "${j}" ]; then
469 dd bs=1 count="${j}" 2>/dev/null
470 "${f}" -sw "$((${c}-${j}))" | sed '2,$s/^/'"${i}"'/'
471 else
472 "${f}" -sw "${c}"
473 fi
474 }
475
476 help() {
477 echo "Usage ${0##*/} [-h|--help] [-c|--clean] [-C|--clean-all] [-l|--list] [-- ] args" | wrap "Usage ${0##*/} "
478 echo " help: print this message" | wrap " "
479 echo " list: list all known chroot environments" | wrap " "
480 echo " clean: remove all old chroot sessions for \"${chroot}\"" | wrap " "
481 echo " clean-all: remove all old chroot sessions for all environments" | wrap " "
482 exit 0
483 }
484
485 clean() {
486 local s t rc
487 rc=0
488 for s in $(schroot -l --all-sessions); do
489 if [ -n "$1" ]; then
490 t="${s#session:}"
491 [ "${t#${chroot}-}" == "${t}" ] && continue
492 fi
493 if ls -l /proc/*/{cwd,fd} 2>/dev/null |
494 fgrep -qs "/var/lib/schroot/mount/${t}"; then
495 echo "Session \"${t}\" still has active users, not cleaning up" | wrap
496 rc=1
497 continue
498 fi
499 sudo schroot -c "${s}" -e || rc=1
500 done
501 exit ${rc}
502 }
503
504 list() {
505 for e in $(schroot -l); do
506 e="${e#chroot:}"
507 [ -x "/usr/local/bin/${e}" ] || continue
508 if schroot -l --all-sessions 2>/dev/null |
509 sed 's/^session://' |
510 grep -qs "^${e}-"; then
511 echo "${e} is currently active"
512 else
513 echo "${e}"
514 fi
515 done
516 exit 0
517 }
518
519 while [ "$#" -ne 0 ]; do
520 case "$1" in
521 --) shift; break;;
522 -h|--help) shift; help;;
523 -l|--list) shift; list;;
524 -c|--clean) shift; clean "${chroot}";;
525 -C|--clean-all) shift; clean;;
526 *) break;;
527 esac
528 done
529
530 # Start a new chroot session and keep track of the session id. We inject this
531 # id into all processes that run inside the chroot. Unless they go out of their
532 # way to clear their environment, we can then later identify our child and
533 # grand-child processes by scanning their environment.
534 session="$(schroot -c "${chroot}" -b)"
535 export CHROOT_SESSION_ID="${session}"
536
537 # Set GOMA_TMP_DIR for better handling of goma inside chroot.
538 export GOMA_TMP_DIR="/tmp/goma_tmp_$CHROOT_SESSION_ID"
539 mkdir -p "$GOMA_TMP_DIR"
540
541 if [ $# -eq 0 ]; then
542 # Run an interactive shell session
543 schroot -c "${session}" -r -p
544 else
545 # Run a command inside of the chroot environment
546 p="$1"; shift
547 schroot -c "${session}" -r -p "$p" -- "$@"
548 fi
549 rc=$?
550
551 # Compute the inode of the root directory inside of the chroot environment.
552 i=$(schroot -c "${session}" -r -p ls -- -id /proc/self/root/. |
553 awk '{ print $1 }') 2>/dev/null
554 other_pids=
555 while [ -n "$i" ]; do
556 # Identify processes by the inode number of their root directory. Then
557 # remove all processes that we know belong to other sessions. We use
558 # "sort | uniq -u" to do what amounts to a "set substraction operation".
559 pids=$({ ls -id1 /proc/*/root/. 2>/dev/null |
560 sed -e 's,^[^0-9]*'$i'.*/\([1-9][0-9]*\)/.*$,\1,
561 t
562 d';
563 echo "${other_pids}";
564 echo "${other_pids}"; } | sort | uniq -u) >/dev/null 2>&1
565 # Kill all processes that are still left running in the session. This is
566 # typically an assortment of daemon processes that were started
567 # automatically. They result in us being unable to tear down the session
568 # cleanly.
569 [ -z "${pids}" ] && break
570 for j in $pids; do
571 # Unfortunately, the way that schroot sets up sessions has the
572 # side-effect of being unable to tell one session apart from another.
573 # This can result in us attempting to kill processes in other sessions.
574 # We make a best-effort to avoid doing so.
575 k="$( ( xargs -0 -n1 </proc/$j/environ ) 2>/dev/null |
576 sed 's/^CHROOT_SESSION_ID=/x/;t1;d;:1;q')"
577 if [ -n "${k}" -a "${k#x}" != "${session}" ]; then
578 other_pids="${other_pids}
579 ${j}"
580 continue
581 fi
582 kill -9 $pids
583 done
584 done
585 # End the chroot session. This should clean up all temporary files. But if we
586 # earlier failed to terminate all (daemon) processes inside of the session,
587 # deleting the session could fail. When that happens, the user has to manually
588 # clean up the stale files by invoking us with "--clean" after having killed
589 # all running processes.
590 schroot -c "${session}" -e
591 # Since no goma processes are running, we can remove goma directory.
592 rm -rf "$GOMA_TMP_DIR"
593 exit $rc
594 EOF
595 sudo chown root:root /usr/local/bin/"${target%bit}"
596 sudo chmod 755 /usr/local/bin/"${target%bit}"
597
598 # Add the standard Ubuntu update repositories if requested.
599 [ "${alt_repos}" = "y" -a \
600 -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
601 sudo sed -i '/^deb .* [^ -]\+ main$/p
602 s/^\(deb .* [^ -]\+\) main/\1-security main/
603 p
604 t1
605 d
606 :1;s/-security main/-updates main/
607 t
608 d' "/var/lib/chroot/${target}/etc/apt/sources.list"
609
610 # Add a few more repositories to the chroot
611 [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
612 sudo sed -i 's/ main$/ main restricted universe multiverse/' \
613 "/var/lib/chroot/${target}/etc/apt/sources.list"
614
615 # Add the Ubuntu "partner" repository, if available
616 if [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
617 HEAD "http://archive.canonical.com/ubuntu/dists/${distname}/partner" \
618 >&/dev/null; then
619 sudo sh -c '
620 echo "deb http://archive.canonical.com/ubuntu" \
621 "'"${distname}"' partner" \
622 >>"/var/lib/chroot/'"${target}"'/etc/apt/sources.list"'
623 fi
624
625 # Add source repositories, if the user requested we do so
626 [ "${add_srcs}" = "y" -a \
627 -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] &&
628 sudo sed -i '/^deb[^-]/p
629 s/^deb\([^-]\)/deb-src\1/' \
630 "/var/lib/chroot/${target}/etc/apt/sources.list"
631
632 # Set apt proxy if host has set http_proxy
633 if [ -n "${http_proxy}" ]; then
634 sudo sh -c '
635 echo "Acquire::http::proxy \"'"${http_proxy}"'\";" \
636 >>"/var/lib/chroot/'"${target}"'/etc/apt/apt.conf"'
637 fi
638
639 # Update packages
640 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
641 apt-get update; apt-get -y dist-upgrade' || :
642
643 # Install a couple of missing packages
644 for i in debian-keyring ubuntu-keyring locales sudo; do
645 [ -d "/var/lib/chroot/${target}/usr/share/doc/$i" ] ||
646 sudo "/usr/local/bin/${target%bit}" apt-get -y install "$i" || :
647 done
648
649 # Configure locales
650 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
651 l='"${LANG:-en_US}"'; l="${l%%.*}"
652 [ -r /etc/locale.gen ] &&
653 sed -i "s/^# \($l\)/\1/" /etc/locale.gen
654 locale-gen $LANG en_US en_US.UTF-8' || :
655
656 # Enable multi-arch support, if available
657 sudo "/usr/local/bin/${target%bit}" dpkg --assert-multi-arch >&/dev/null &&
658 [ -r "/var/lib/chroot/${target}/etc/apt/sources.list" ] && {
659 sudo sed -i 's/ / [arch=amd64,i386] /' \
660 "/var/lib/chroot/${target}/etc/apt/sources.list"
661 [ -d /var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/ ] &&
662 sudo "/usr/local/bin/${target%bit}" dpkg --add-architecture \
663 $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) >&/dev/null ||
664 echo foreign-architecture \
665 $([ "${arch}" = "32bit" ] && echo amd64 || echo i386) |
666 sudo sh -c \
667 "cat >'/var/lib/chroot/${target}/etc/dpkg/dpkg.cfg.d/multiarch'"
668 }
669
670 # Configure "sudo" package
671 sudo "/usr/local/bin/${target%bit}" /bin/sh -c '
672 egrep -qs '"'^$(id -nu) '"' /etc/sudoers ||
673 echo '"'$(id -nu) ALL=(ALL) ALL'"' >>/etc/sudoers'
674
675 # Install a few more commonly used packages
676 sudo "/usr/local/bin/${target%bit}" apt-get -y install \
677 autoconf automake1.9 dpkg-dev g++-multilib gcc-multilib gdb less libtool \
678 lsof strace
679
680 # If running a 32bit environment on a 64bit machine, install a few binaries
681 # as 64bit. This is only done automatically if the chroot distro is the same as
682 # the host, otherwise there might be incompatibilities in build settings or
683 # runtime dependencies. The user can force it with the '-c' flag.
684 host_distro=$(grep -s DISTRIB_CODENAME /etc/lsb-release | \
685 cut -d "=" -f 2)
686 if [ "${copy_64}" = "y" -o \
687 "${host_distro}" = "${distname}" -a "${arch}" = 32bit ] && \
688 file /bin/bash 2>/dev/null | grep -q x86-64; then
689 readlinepkg=$(sudo "/usr/local/bin/${target%bit}" sh -c \
690 'apt-cache search "lib64readline.\$" | sort | tail -n 1 | cut -d " " -f 1')
691 sudo "/usr/local/bin/${target%bit}" apt-get -y install \
692 lib64expat1 lib64ncurses5 ${readlinepkg} lib64z1 lib64stdc++6
693 dep=
694 for i in binutils gdb; do
695 [ -d /usr/share/doc/"$i" ] || dep="$dep $i"
696 done
697 [ -n "$dep" ] && sudo apt-get -y install $dep
698 sudo mkdir -p "/var/lib/chroot/${target}/usr/local/lib/amd64"
699 for i in libbfd libpython; do
700 lib="$({ ldd /usr/bin/ld; ldd /usr/bin/gdb; } |
701 grep -s "$i" | awk '{ print $3 }')"
702 if [ -n "$lib" -a -r "$lib" ]; then
703 sudo cp "$lib" "/var/lib/chroot/${target}/usr/local/lib/amd64"
704 fi
705 done
706 for lib in libssl libcrypt; do
707 for path in /usr/lib /usr/lib/x86_64-linux-gnu; do
708 sudo cp $path/$lib* \
709 "/var/lib/chroot/${target}/usr/local/lib/amd64/" >&/dev/null || :
710 done
711 done
712 for i in gdb ld; do
713 sudo cp /usr/bin/$i "/var/lib/chroot/${target}/usr/local/lib/amd64/"
714 sudo sh -c "cat >'/var/lib/chroot/${target}/usr/local/bin/$i'" <<EOF
715 #!/bin/sh
716 exec /lib64/ld-linux-x86-64.so.2 --library-path /usr/local/lib/amd64 \
717 /usr/local/lib/amd64/$i "\$@"
718 EOF
719 sudo chmod 755 "/var/lib/chroot/${target}/usr/local/bin/$i"
720 done
721 fi
722
723
724 # If the install-build-deps.sh script can be found, offer to run it now
725 script="$(dirname $(readlink -f "$0"))/install-build-deps.sh"
726 if [ -x "${script}" ]; then
727 while :; do
728 echo
729 echo "If you plan on building Chrome inside of the new chroot environment,"
730 echo "you now have to install the build dependencies. Do you want me to"
731 printf "start the script that does this for you (y/n)? "
732 read install_deps
733 case "${install_deps}" in
734 y|Y)
735 echo
736 # We prefer running the script in-place, but this might not be
737 # possible, if it lives on a network filesystem that denies
738 # access to root.
739 tmp_script=
740 if ! sudo /usr/local/bin/"${target%bit}" \
741 sh -c "[ -x '${script}' ]" >&/dev/null; then
742 tmp_script="/tmp/${script##*/}"
743 cp "${script}" "${tmp_script}"
744 fi
745 # Some distributions automatically start an instance of the system-
746 # wide dbus daemon, cron daemon or of the logging daemon, when
747 # installing the Chrome build depencies. This prevents the chroot
748 # session from being closed. So, we always try to shut down any running
749 # instance of dbus and rsyslog.
750 sudo /usr/local/bin/"${target%bit}" sh -c "${script};
751 rc=$?;
752 /etc/init.d/cron stop >/dev/null 2>&1 || :;
753 /etc/init.d/rsyslog stop >/dev/null 2>&1 || :;
754 /etc/init.d/dbus stop >/dev/null 2>&1 || :;
755 exit $rc"
756 rc=$?
757 [ -n "${tmp_script}" ] && rm -f "${tmp_script}"
758 [ $rc -ne 0 ] && exit $rc
759 break
760 ;;
761 n|N)
762 break
763 ;;
764 esac
765 done
766 echo
767 fi
768
769 # Check whether ~/chroot is on a (slow) network file system and offer to
770 # relocate it. Also offer relocation, if the user appears to have multiple
771 # spindles (as indicated by "${bind_mount}" being non-empty).
772 # We only offer this option, if it doesn't look as if a chroot environment
773 # is currently active. Otherwise, relocation is unlikely to work and it
774 # can be difficult for the user to recover from the failed attempt to relocate
775 # the ~/chroot directory.
776 # We don't aim to solve this problem for every configuration,
777 # but try to help with the common cases. For more advanced configuration
778 # options, the user can always manually adjust things.
779 mkdir -p "${HOME}/chroot/"
780 if [ ! -h "${HOME}/chroot" ] &&
781 ! egrep -qs '^[^[:space:]]*/chroot' /etc/fstab &&
782 { [ -n "${bind_mounts}" -a "${bind_mounts}" != "NONE" ] ||
783 is_network_drive "${HOME}/chroot"; } &&
784 ! egrep -qs '/var/lib/[^/]*chroot/.*/chroot' /proc/mounts; then
785 echo "${HOME}/chroot is currently located on the same device as your"
786 echo "home directory."
787 echo "This might not be what you want. Do you want me to move it somewhere"
788 echo "else?"
789 # If the computer has multiple spindles, many users configure all or part of
790 # the secondary hard disk to be writable by the primary user of this machine.
791 # Make some reasonable effort to detect this type of configuration and
792 # then offer a good location for where to put the ~/chroot directory.
793 suggest=
794 for i in $(echo "${bind_mounts}"|cut -d ' ' -f 1); do
795 if [ -d "$i" -a -w "$i" -a \( ! -a "$i/chroot" -o -w "$i/chroot/." \) ] &&
796 ! is_network_drive "$i"; then
797 suggest="$i"
798 else
799 for j in "$i/"*; do
800 if [ -d "$j" -a -w "$j" -a \
801 \( ! -a "$j/chroot" -o -w "$j/chroot/." \) ] &&
802 ! is_network_drive "$j"; then
803 suggest="$j"
804 else
805 for k in "$j/"*; do
806 if [ -d "$k" -a -w "$k" -a \
807 \( ! -a "$k/chroot" -o -w "$k/chroot/." \) ] &&
808 ! is_network_drive "$k"; then
809 suggest="$k"
810 break
811 fi
812 done
813 fi
814 [ -n "${suggest}" ] && break
815 done
816 fi
817 [ -n "${suggest}" ] && break
818 done
819 def_suggest="${HOME}"
820 if [ -n "${suggest}" ]; then
821 # For home directories that reside on network drives, make our suggestion
822 # the default option. For home directories that reside on a local drive,
823 # require that the user manually enters the new location.
824 if is_network_drive "${HOME}"; then
825 def_suggest="${suggest}"
826 else
827 echo "A good location would probably be in \"${suggest}\""
828 fi
829 fi
830 while :; do
831 printf "Physical location [${def_suggest}]: "
832 read dir
833 [ -z "${dir}" ] && dir="${def_suggest}"
834 [ "${dir%%/}" == "${HOME%%/}" ] && break
835 if ! [ -d "${dir}" -a -w "${dir}" ] ||
836 [ -a "${dir}/chroot" -a ! -w "${dir}/chroot/." ]; then
837 echo "Cannot write to ${dir}/chroot. Please try again"
838 else
839 mv "${HOME}/chroot" "${dir}/chroot"
840 ln -s "${dir}/chroot" "${HOME}/chroot"
841 for i in $(list_all_chroots); do
842 sudo "$i" mkdir -p "${dir}/chroot"
843 done
844 sudo sed -i "s,${HOME}/chroot,${dir}/chroot,g" /etc/schroot/mount-*
845 break
846 fi
847 done
848 fi
849
850 # Clean up package files
851 sudo schroot -c "${target%bit}" -p -- apt-get clean
852 sudo apt-get clean
853
854 trap '' INT TERM QUIT HUP
855 trap '' EXIT
856
857 # Let the user know what we did
858 cat <<EOF
859
860
861 Successfully installed ${distname} ${arch}
862
863 You can run programs inside of the chroot by invoking the
864 "/usr/local/bin/${target%bit}" command.
865
866 This command can be used with arguments, in order to just run a single
867 program inside of the chroot environment (e.g. "${target%bit} make chrome")
868 or without arguments, in order to run an interactive shell session inside
869 of the chroot environment.
870
871 If you need to run things as "root", you can use "sudo" (e.g. try
872 "sudo ${target%bit} apt-get update").
873
874 Your home directory is shared between the host and the chroot. But I
875 configured "${HOME}/chroot" to be private to the chroot environment.
876 You can use it for files that need to differ between environments. This
877 would be a good place to store binaries that you have built from your
878 source files.
879
880 For Chrome, this probably means you want to make your "out" directory a
881 symbolic link that points somewhere inside of "${HOME}/chroot".
882
883 You still need to run "gclient runhooks" whenever you switch from building
884 outside of the chroot to inside of the chroot. But you will find that you
885 don't have to repeatedly erase and then completely rebuild all your object
886 and binary files.
887
888 EOF
OLDNEW
« no previous file with comments | « build/install-build-deps-android.sh ('k') | build/internal/README.chromium » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698