git.onelab.eu Git - build.git/blob

1 #!/bin/bash

2 # -*-shell-*-

4 #shopt -s huponexit

6 COMMAND=$(basename $0)

7 DIRNAME=$(dirname $0)

8 BUILD_DIR=$(pwd)

10 # pkgs parsing utilities

11 PATH=$(dirname $0):$PATH export PATH

12 . build.common

14 DEFAULT_FCDISTRO=f20

15 DEFAULT_PLDISTRO=lxc

16 DEFAULT_PERSONALITY=linux64

18 COMMAND_LBUILD="lbuild-initvm.sh"

19 COMMAND_LTEST="ltest-initvm.sh"

21 ##########

22 # when creating build boxes we use private NAT'ed addresses for the VMs

23 # as per virbr0 that is taken care of by libvirt at startup

24 PRIVATE_BRIDGE="virbr0"

25 PRIVATE_PREFIX="192.168.122."

26 PRIVATE_GATEWAY="192.168.122.1"

27 # beware that changing this would break the logic of random_private_byte...

28 PRIVATE_MASKLEN=24

30 # we just try randomly in that range until a free IP address shows up

31 PRIVATE_ATTEMPTS=20

33 # constant

34 PUBLIC_BRIDGE=br0

36 # the network interface name as seen from the container

37 VIF_GUEST=eth0

39 ##############################

40 ## stolen from tests/system/template-qemu/qemu-bridge-init

41 # use /proc/net/dev instead of a hard-wired list

42 function gather_interfaces () {

43 python <<EOF

44 for line in file("/proc/net/dev"):

45 if ':' not in line: continue

46 ifname=line.replace(" ","").split(":")[0]

47 if ifname.find("lo")==0: continue

48 if ifname.find("br")==0: continue

49 if ifname.find("virbr")==0: continue

50 if ifname.find("tap")==0: continue

51 print ifname

52 EOF

53 }

55 function discover_interface () {

56 for ifname in $(gather_interfaces); do

57 ip link show $ifname | grep -qi 'state UP' && { echo $ifname; return; }

58 done

59 # still not found ? that's bad

60 echo unknown

61 }

62 ########## check for a free IP

63 function ip_is_busy () {

64 target=$1; shift

65 ping -c 1 -W 1 $target >& /dev/null

66 }

68 function random_private_byte () {

69 for attempt in $(seq $PRIVATE_ATTEMPTS); do

70 byte=$(($RANDOM % 256))

71 if [ "$byte" == 0 -o "$byte" == 1 ] ; then continue; fi

72 ip=${PRIVATE_PREFIX}${byte}

73 ip_is_busy $ip || { echo $byte; return; }

74 done

75 echo "Cannot seem to find a free IP address in range ${PRIVATE_PREFIX}.xx/24 after $PRIVATE_ATTEMPTS attempts - exiting"

76 exit 1

77 }

79 ########## networking -- ctd

80 function gethostbyname () {

81 hostname=$1

82 python -c "import socket; print socket.gethostbyname('"$hostname"')" 2> /dev/null

83 }

85 # e.g. 21 -> 255.255.248.0

86 function masklen_to_netmask () {

87 masklen=$1; shift

88 python <<EOF

89 import sys

90 masklen=$masklen

91 if not (masklen>=1 and masklen<=32):

92 print "Wrong masklen",masklen

93 exit(1)

94 result=[]

95 for i in range(4):

96 if masklen>=8:

97 result.append(8)

98 masklen-=8

99 else:

100 result.append(masklen)

101 masklen=0

102 print ".".join([ str(256-2**(8-i)) for i in result ])

103

104 EOF

105 }

106

107 #################### bridge initialization

108 function create_bridge_if_needed() {

109

110 # turn on verbosity

111 set -x

112

113 # already created ? - we're done

114 ip addr show $PUBLIC_BRIDGE >& /dev/null && {

115 echo "Bridge already set up - skipping create_bridge_if_needed"

116 return 0

117 }

118

119 # find out the physical interface to bridge onto

120 if_lan=$(discover_interface)

121

122 ip addr show $if_lan &>/dev/null || {

123 echo "Cannot use interface $if_lan - exiting"

124 exit 1

125 }

126

127 #################### bride initialization

128 check_yum_installed bridge-utils

129

130 echo "========== $COMMAND: entering create_bridge - beg"

131 hostname

132 uname -a

133 ip addr show

134 ip route

135 echo "========== $COMMAND: entering create_bridge - end"

136

137 # disable netfilter calls for bridge interface (they cause panick on 2.6.35 anyway)

138 #

139 # another option would be to accept the all forward packages for

140 # bridged interface like: -A FORWARD -m physdev --physdev-is-bridged -j ACCEPT

141 sysctl net.bridge.bridge-nf-call-iptables=0

142 sysctl net.bridge.bridge-nf-call-ip6tables=0

143 sysctl net.bridge.bridge-nf-call-arptables=0

144

145

146 #Getting host IP/masklen

147 address=$(ip addr show $if_lan | grep -v inet6 | grep inet | head --lines=1 | awk '{print $2;}')

148 [ -z "$address" ] && { echo "ERROR: Could not determine IP address for $if_lan" ; exit 1 ; }

149

150 broadcast=$(ip addr show $if_lan | grep -v inet6 | grep inet | head --lines=1 | awk '{print $4;}')

151 [ -z "$broadcast" ] && echo "WARNING: Could not determine broadcast address for $if_lan"

152

153 gateway=$(ip route show | grep default | awk '{print $3;}')

154 [ -z "$gateway" ] && echo "WARNING: Could not determine gateway IP"

155

156

157 # creating the bridge

158 echo "Creating bridge PUBLIC_BRIDGE=$PUBLIC_BRIDGE"

159 brctl addbr $PUBLIC_BRIDGE

160 brctl addif $PUBLIC_BRIDGE $if_lan

161 echo "Activating promiscuous mode if_lan=$if_lan"

162 ip link set $if_lan up promisc on

163 sleep 2

164 # rely on dhcp to re assign IP..

165 echo "Starting dhclient on $PUBLIC_BRIDGE"

166 dhclient $PUBLIC_BRIDGE

167 sleep 1

168

169 #Reconfigure the routing table

170 echo "Configuring gateway=$gateway"

171 ip route add default via $gateway dev $PUBLIC_BRIDGE

172 ip route del default via $gateway dev $if_lan

173 # at this point we have an extra route like e.g.

174 ## ip route show

175 #default via 138.96.112.250 dev br0

176 #138.96.112.0/21 dev em1 proto kernel scope link src 138.96.112.57

177 #138.96.112.0/21 dev br0 proto kernel scope link src 138.96.112.57

178 #192.168.122.0/24 dev virbr0 proto kernel scope link src 192.168.122.1

179 route_dest=$(ip route show | grep -v default | grep "dev $PUBLIC_BRIDGE" | awk '{print $1;}')

180 ip route del $route_dest dev $if_lan

181

182 echo "========== $COMMAND: exiting create_bridge - beg"

183 ip addr show

184 ip route show

185 echo "========== $COMMAND: exiting create_bridge - end"

186

187 # for safety

188 sleep 3

189 return 0

190

191 }

192

193 ##############################

194 # return yum or debootstrap

195 function package_method () {

196 fcdistro=$1; shift

197 case $fcdistro in

198 f[0-9]*|centos[0-9]*|sl[0-9]*) echo yum ;;

200 *) echo Unknown distro $fcdistro ;;

201 esac

202 }

203

204 # return arch from debian distro and personality

205 function canonical_arch () {

206 personality=$1; shift

207 fcdistro=$1; shift

208 case $(package_method $fcdistro) in

209 yum)

210 case $personality in *32) echo i386 ;; *64) echo x86_64 ;; *) echo Unknown-arch-1 ;; esac ;;

211 debootstrap)

212 case $personality in *32) echo i386 ;; *64) echo amd64 ;; *) echo Unknown-arch-2 ;; esac ;;

213 *)

214 echo Unknown-arch-3 ;;

215 esac

216 }

217

218 # the new test framework creates /timestamp in /vservers/<name> *before* populating it

219 function almost_empty () {

220 dir="$1"; shift ;

221 # non existing is fine

222 [ ! -d $dir ] && return 0;

223 # need to have at most one file

224 count=$(cd $dir; ls | wc -l); [ $count -le 1 ];

225 }

226

227 ##############################

228 function check_yum_installed () {

229 package=$1; shift

230 rpm -q $package >& /dev/null || yum -y install $package

231 }

232

233 function check_yumgroup_installed () {

234 group="$1"; shift

235 yum grouplist "$group" | grep -q Installed || { yum -y groupinstall "$group" ; }

236 }

237

238 ##############################

239 function fedora_install() {

240 set -x

241 set -e

242

243 mkdir -p /var/lock/subsys/

244 (

245 flock -n -x 200 || { echo "Cache repository is busy." ; return 1 ; }

246

247 if [ ! -e "$cache/rootfs" ]; then

248 echo "Getting cache download in $cache/rootfs ... "

249 fedora_download || { echo "Failed to download 'fedora base'"; return 1; }

250 else

251 echo "Updating cache $cache/rootfs ..."

252 if ! yum --installroot $cache/rootfs -y --nogpgcheck update ; then

253 echo "Failed to update 'fedora base', continuing with last known good cache"

254 else

255 echo "Update finished"

256 fi

257 fi

258

259 echo "Copy $cache/rootfs to $rootfs_path ... "

260 mkdir -p $rootfs_path

261 rsync -a $cache/rootfs/ $rootfs_path/

262

263 return 0

264

265 ) 200>/var/lock/subsys/lxc

266

267 return $?

268 }

269

270 function fedora_download() {

271 set -x

272 # check the mini fedora was not already downloaded

273 INSTALL_ROOT=$cache/partial

274 echo $INSTALL_ROOT

275

276 # download a mini fedora into a cache

277 echo "Downloading fedora minimal ..."

278

279 mkdir -p $INSTALL_ROOT || { echo "Failed to create '$INSTALL_ROOT' directory" ; return 1; }

280

281 mkdir -p $INSTALL_ROOT/etc/yum.repos.d

282 mkdir -p $INSTALL_ROOT/dev

283 mknod -m 0444 $INSTALL_ROOT/dev/random c 1 8

284 mknod -m 0444 $INSTALL_ROOT/dev/urandom c 1 9

285

286 # copy yum config and repo files

287 cp /etc/yum.conf $INSTALL_ROOT/etc/

288 cp /etc/yum.repos.d/fedora* $INSTALL_ROOT/etc/yum.repos.d/

289

290 # append fedora repo files with desired $release and $basearch

291 for f in $INSTALL_ROOT/etc/yum.repos.d/* ; do

292 sed -i "s/\$basearch/$arch/g; s/\$releasever/$release/g;" $f

293 done

294

295 MIRROR_URL=http://mirror.onelab.eu/fedora/releases/$release/Everything/$arch/os

296 RELEASE_URL1="$MIRROR_URL/Packages/fedora-release-$release-1.noarch.rpm"

297 # with fedora18 the rpms are scattered by first name

298 RELEASE_URL2="$MIRROR_URL/Packages/f/fedora-release-$release-1.noarch.rpm"

299 RELEASE_TARGET=$INSTALL_ROOT/fedora-release-$release.noarch.rpm

300 found=""

301 for attempt in $RELEASE_URL1 $RELEASE_URL2; do

302 if curl -f $attempt -o $RELEASE_TARGET ; then

303 echo "Retrieved $attempt"

304 found=true

305 break

306 else

307 echo "Failed attempt $attempt"

308 fi

309 done

310 [ -n "$found" ] || { echo "Could not retrieve fedora-release rpm - exiting" ; exit 1; }

311

312 mkdir -p $INSTALL_ROOT/var/lib/rpm

313 rpm --root $INSTALL_ROOT --initdb

314 # when installing f12 this apparently is already present, so ignore result

315 rpm --root $INSTALL_ROOT -ivh $INSTALL_ROOT/fedora-release-$release.noarch.rpm || :

316 # however f12 root images won't get created on a f18 host

317 # (the issue here is the same as the one we ran into when dealing with a vs-box)

318 # in a nutshell, in f12 the glibc-common and filesystem rpms have an apparent conflict

319 # >>> file /usr/lib/locale from install of glibc-common-2.11.2-3.x86_64 conflicts

320 # with file from package filesystem-2.4.30-2.fc12.x86_64

321 # in fact this was - of course - allowed by f12's rpm but later on a fix was made

322 # http://rpm.org/gitweb?p=rpm.git;a=commitdiff;h=cf1095648194104a81a58abead05974a5bfa3b9a

323 # So ideally if we want to be able to build f12 images from f18 we need an rpm that has

324 # this patch undone, like we have in place on our f14 boxes (our f14 boxes need a f18-like rpm)

325

326 YUM="yum --installroot=$INSTALL_ROOT --nogpgcheck -y"

327 PKG_LIST="yum initscripts passwd rsyslog vim-minimal dhclient chkconfig rootfiles policycoreutils openssh-server openssh-clients"

328 echo "$YUM install $PKG_LIST"

329 $YUM install $PKG_LIST || { echo "Failed to download rootfs, aborting." ; return 1; }

330

331 mv "$INSTALL_ROOT" "$cache/rootfs"

332 echo "Download complete."

333

334 return 0

335 }

336

337 ##############################

338 function fedora_configure() {

339

340 set -x

341 set -e

342

343 # disable selinux in fedora

344 mkdir -p $rootfs_path/selinux

345 echo 0 > $rootfs_path/selinux/enforce

346

347 # set the hostname

348 case "$fcdistro" in

349 f18|f2?)

350 cat <<EOF > ${rootfs_path}/etc/hostname

351 $GUEST_HOSTNAME

352 EOF

353 echo ;;

354 *)

355 cat <<EOF > ${rootfs_path}/etc/sysconfig/network

356 NETWORKING=yes

357 HOSTNAME=$GUEST_HOSTNAME

358 EOF

359 # set minimal hosts

360 cat <<EOF > $rootfs_path/etc/hosts

361 127.0.0.1 localhost $GUEST_HOSTNAME

362 EOF

363 echo ;;

364 esac

365

366 dev_path="${rootfs_path}/dev"

367 rm -rf $dev_path

368 mkdir -p $dev_path

369 mknod -m 666 ${dev_path}/null c 1 3

370 mknod -m 666 ${dev_path}/zero c 1 5

371 mknod -m 666 ${dev_path}/random c 1 8

372 mknod -m 666 ${dev_path}/urandom c 1 9

373 mkdir -m 755 ${dev_path}/pts

374 mkdir -m 1777 ${dev_path}/shm

375 mknod -m 666 ${dev_path}/tty c 5 0

376 mknod -m 666 ${dev_path}/tty0 c 4 0

377 mknod -m 666 ${dev_path}/tty1 c 4 1

378 mknod -m 666 ${dev_path}/tty2 c 4 2

379 mknod -m 666 ${dev_path}/tty3 c 4 3

380 mknod -m 666 ${dev_path}/tty4 c 4 4

381 mknod -m 600 ${dev_path}/console c 5 1

382 mknod -m 666 ${dev_path}/full c 1 7

383 mknod -m 600 ${dev_path}/initctl p

384 mknod -m 666 ${dev_path}/ptmx c 5 2

385

386 #echo "setting root passwd to $root_password"

387 #echo "root:$root_password" | chroot $rootfs_path chpasswd

388

389 if [ "$(echo $fcdistro | cut -d"f" -f2)" -le "14" ]; then

390 fedora_configure_init

391 else

392 fedora_configure_systemd

393 fi

394

395 fedora_configure_yum $lxc $fcdistro $pldistro

396

397 return 0

398 }

399

400 function fedora_configure_init() {

401 set -e

402 set -x

403 sed -i 's|.sbin.start_udev||' ${rootfs_path}/etc/rc.sysinit

404 sed -i 's|.sbin.start_udev||' ${rootfs_path}/etc/rc.d/rc.sysinit

405 # don't mount devpts, for pete's sake

406 sed -i 's/^.*dev.pts.*$/#\0/' ${rootfs_path}/etc/rc.sysinit

407 sed -i 's/^.*dev.pts.*$/#\0/' ${rootfs_path}/etc/rc.d/rc.sysinit

408 chroot ${rootfs_path} /sbin/chkconfig udev-post off

409 chroot ${rootfs_path} /sbin/chkconfig network on

410 }

411

412 # this code of course is for guests that do run on systemd

413 function fedora_configure_systemd() {

414 set -e

415 set -x

416 # so ignore if we can't find /etc/systemd at all

417 [ -d ${rootfs_path}/etc/systemd ] || return 0

418 # otherwise let's proceed

419 ln -sf /lib/systemd/system/multi-user.target ${rootfs_path}/etc/systemd/system/default.target

420 touch ${rootfs_path}/etc/fstab

421 ln -sf /dev/null ${rootfs_path}/etc/systemd/system/udev.service

422 # Thierry - Feb 2013

423 # this was intended for f16 initially, in order to enable getty that otherwise would not start

424 # having a getty running is helpful only if ssh won't start though, and we see a correlation between

425 # VM's that refuse to lxc-stop and VM's that run crazy getty's

426 # so, turning getty off for now instead

427 # #dependency on a device unit fails it specially that we disabled udev

428 # sed -i 's/After=dev-%i.device/After=/' ${rootfs_path}/lib/systemd/system/getty\@.service

429 ln -sf /dev/null ${rootfs_path}/etc/systemd/system/"getty@.service"

430 rm -f ${rootfs_path}/etc/systemd/system/getty.target.wants/*service || :

431 # can't seem to handle this one with systemctl

432 chroot ${rootfs_path} /sbin/chkconfig network on

433 }

434

435 # overwrite container yum config

436 function fedora_configure_yum () {

437 set -x

438 set -e

439 trap failure ERR INT

440

441 lxc=$1; shift

442 fcdistro=$1; shift

443 pldistro=$1; shift

444

445 # rpm --rebuilddb

446 chroot $rootfs_path /bin/rpm --rebuilddb

447

448 echo "Initializing yum.repos.d in $lxc"

449 rm -f $rootfs_path/etc/yum.repos.d/*

450

451 cat > $rootfs_path/etc/yum.repos.d/building.repo <<EOF

452 [fedora]

453 name=Fedora $release - $arch

454 baseurl=http://mirror.onelab.eu/fedora/releases/$release/Everything/$arch/os/

455 enabled=1

456 metadata_expire=7d

457 gpgcheck=1

458 gpgkey=http://mirror.onelab.eu/keys/RPM-GPG-KEY-fedora-$release-primary

459

460 [updates]

461 name=Fedora $release - $arch - Updates

462 baseurl=http://mirror.onelab.eu/fedora/updates/$release/$arch/

463 enabled=1

464 metadata_expire=7d

465 gpgcheck=1

466 gpgkey=http://mirror.onelab.eu/keys/RPM-GPG-KEY-fedora-$release-primary

467 EOF

468

469 # for using vtest-init-lxc.sh as a general-purpose lxc creation wrapper

470 # just mention 'none' as the repo url

471 if [ -n "$REPO_URL" ] ; then

472 if [ ! -d $rootfs_path/etc/yum.repos.d ] ; then

473 echo "WARNING : cannot create myplc repo"

474 else

475 # exclude kernel from fedora repos

476 yumexclude=$(pl_plcyumexclude $fcdistro $pldistro $DIRNAME)

477 for repo in $rootfs_path/etc/yum.repos.d/* ; do

478 [ -f $repo ] && yumconf_exclude $repo "exclude=$yumexclude"

479 done

480 # the build repo is not signed at this stage

481 cat > $rootfs_path/etc/yum.repos.d/myplc.repo <<EOF

482 [myplc]

483 name= MyPLC

484 baseurl=$REPO_URL

485 enabled=1

486 gpgcheck=0

487 EOF

488 fi

489 fi

490 }

491

492 ##############################

493 # need to specify the right mirror for debian variants like ubuntu and the like

494 function debian_mirror () {

495 fcdistro=$1; shift

496 case $fcdistro in

497 squeeze|wheezy)

498 echo http://ftp2.fr.debian.org/debian/ ;;

499 oneiric|precise|quantal|raring|saucy)

500 echo http://mir1.ovh.net/ubuntu/ubuntu/ ;;

501 *) echo unknown distro $fcdistro; exit 1;;

502 esac

503 }

504

505 function debian_install () {

506 set -e

507 set -x

508 mkdir -p $rootfs_path

509 arch=$(canonical_arch $personality $fcdistro)

510 mirror=$(debian_mirror $fcdistro)

511 # old guests have mount in /bin but this is no longer part of

512 # the standard PATH in recent hosts

513 PATH=$PATH:/bin:/sbin debootstrap --arch $arch $fcdistro $rootfs_path $mirror

514 }

515

516 function debian_configure () {

517 echo "WARNING No debian config available yet"

518 }

519 ##############################

520 function setup_lxc() {

521

522 set -x

523 set -e

524 #trap failure ERR INT

525

526 lxc=$1; shift

527 fcdistro=$1; shift

528 pldistro=$1; shift

529 personality=$1; shift

530

531 # create lxc container

532

533 pkg_method=$(package_method $fcdistro)

534 case $pkg_method in

535 yum)

536 fedora_install || { echo "failed to install fedora root image"; exit 1 ; }

537 fedora_configure || { echo "failed to configure fedora for a container"; exit 1 ; }

538 ;;

539 debootstrap)

540 debian_install || { echo "failed to install debian/ubuntu root image"; exit 1 ; }

541 debian_configure || { echo "failed to configure debian/ubuntu for a container"; exit 1 ; }

542 ;;

543 *)

544 echo "$COMMAND:: unknown package_method - exiting"

545 exit 1

546 ;;

547 esac

548

549 # Enable cgroup -- xxx -- is this really useful ?

550 mkdir $rootfs_path/cgroup

551

552 # set up resolv.conf

553 cp /etc/resolv.conf $rootfs_path/etc/resolv.conf

554 # and /etc/hosts for at least localhost

555 [ -f $rootfs_path/etc/hosts ] || echo "127.0.0.1 localhost localhost.localdomain" > $rootfs_path/etc/hosts

556

557 # grant ssh access from host to guest

558 mkdir $rootfs_path/root/.ssh

559 cat /root/.ssh/id_rsa.pub >> $rootfs_path/root/.ssh/authorized_keys

560

561 config_xml=$config_path/"lxc.xml"

562 guest_ifcfg=${rootfs_path}/etc/sysconfig/network-scripts/ifcfg-$VIF_GUEST

563 if [ -n "$BUILD_MODE" ] ; then

564 write_lxc_xml_build $lxc > $config_xml

565 write_guest_ifcfg_build > $guest_ifcfg

566 else

567 write_lxc_xml_test $lxc > $config_xml

568 write_guest_ifcfg_test > $guest_ifcfg

569 fi

570

571 # define lxc container for libvirt

572 virsh -c lxc:/// define $config_xml

573

574 return 0

575 }

576

577 function write_lxc_xml_test () {

578 lxc=$1; shift

579 cat <<EOF

580 <domain type='lxc'>

581 <name>$lxc</name>

582 <memory>524288</memory>

583 <os>

584 <type arch='$arch2'>exe</type>

585 <init>/sbin/init</init>

586 </os>

587 <features>

588 <acpi/>

589 </features>

590 <vcpu>1</vcpu>

591 <clock offset='utc'/>

592 <on_poweroff>destroy</on_poweroff>

593 <on_reboot>restart</on_reboot>

594 <on_crash>destroy</on_crash>

595 <devices>

596 <emulator>/usr/libexec/libvirt_lxc</emulator>

597 <filesystem type='mount'>

598 <source dir='$rootfs_path'/>

599 <target dir='/'/>

600 </filesystem>

601 <interface type="bridge">

602 <source bridge="$PUBLIC_BRIDGE"/>

603 <target dev='$VIF_HOST'/>

604 </interface>

605 <console type='pty' />

606 </devices>

607 <network>

608 <name>host-bridge</name>

609 <forward mode="bridge"/>

610 <bridge name="$PUBLIC_BRIDGE"/>

611 </network>

612 </domain>

613 EOF

614 }

615

616 function write_lxc_xml_build () {

617 lxc=$1; shift

618 cat <<EOF

619 <domain type='lxc'>

620 <name>$lxc</name>

621 <memory>524288</memory>

622 <os>

623 <type arch='$arch2'>exe</type>

624 <init>/sbin/init</init>

625 </os>

626 <features>

627 <acpi/>

628 </features>

629 <vcpu>1</vcpu>

630 <clock offset='utc'/>

631 <on_poweroff>destroy</on_poweroff>

632 <on_reboot>restart</on_reboot>

633 <on_crash>destroy</on_crash>

634 <devices>

635 <emulator>/usr/libexec/libvirt_lxc</emulator>

636 <filesystem type='mount'>

637 <source dir='$rootfs_path'/>

638 <target dir='/'/>

639 </filesystem>

640 <interface type="network">

641 <source network="default"/>

642 </interface>

643 <console type='pty' />

644 </devices>

645 </domain>

646 EOF

647 }

648

649 # this one is dhcp-based

650 function write_guest_ifcfg_build () {

651 cat <<EOF

652 DEVICE=$VIF_GUEST

653 BOOTPROTO=dhcp

654 ONBOOT=yes

655 NM_CONTROLLED=no

656 TYPE=Ethernet

657 MTU=1500

658 EOF

659 }

660

661 # use fixed IP as specified by GUEST_HOSTNAME

662 function write_guest_ifcfg_test () {

663 cat <<EOF

664 DEVICE=$VIF_GUEST

665 BOOTPROTO=static

666 ONBOOT=yes

667 HOSTNAME=$GUEST_HOSTNAME

668 IPADDR=$IP

669 NETMASK=$NETMASK

670 GATEWAY=$GATEWAY

671 NM_CONTROLLED=no

672 TYPE=Ethernet

673 MTU=1500

674 EOF

675 }

676

677 function devel_or_vtest_tools () {

678

679 set -x

680 set -e

681 trap failure ERR INT

682

683 lxc=$1; shift

684 fcdistro=$1; shift

685 pldistro=$1; shift

686 personality=$1; shift

687

688 pkg_method=$(package_method $fcdistro)

689

690 pkgsfile=$(pl_locateDistroFile $DIRNAME $pldistro $PREINSTALLED)

691

692 ### install individual packages, then groups

693 # get target arch - use uname -i here (we want either x86_64 or i386)

694

695 lxc_arch=$(chroot $rootfs_path /bin/uname -i)

696 # on debian systems we get arch through the 'arch' command

697 [ "$lxc_arch" = "unknown" ] && lxc_arch=$(chroot $rootfs_path /bin/arch)

698

699 packages=$(pl_getPackages -a $lxc_arch $fcdistro $pldistro $pkgsfile)

700 groups=$(pl_getGroups -a $lxc_arch $fcdistro $pldistro $pkgsfile)

701

702 case "$pkg_method" in

703 yum)

704 [ -n "$packages" ] && chroot $rootfs_path /usr/bin/yum -y install $packages

705 for group_plus in $groups; do

706 group=$(echo $group_plus | sed -e "s,+++, ,g")

707 chroot $rootfs_path /usr/bin/yum -y groupinstall "$group"

708 done

709 # store current rpm list in /init-lxc.rpms in case we need to check the contents

710 chroot $rootfs_path /bin/rpm -aq > $rootfs_path/init-lxc.rpms

711 ;;

712 debootstrap)

713 chroot $rootfs_path /usr/bin/apt-get update

714 for package in $packages ; do

715 chroot $rootfs_path /usr/bin/apt-get install -y $package

716 done

717 ### xxx todo install groups with apt..

718 ;;

719 *)

720 echo "unknown pkg_method $pkg_method"

721 ;;

722 esac

723

724 return 0

725 }

726

727 function post_install () {

728 lxc=$1; shift

729 personality=$1; shift

730 if [ -n "$BUILD_MODE" ] ; then

731 post_install_build $lxc $personality

732 lxc_start $lxc

733 # manually run dhclient in guest - somehow this network won't start on its own

734 virsh -c lxc:/// lxc-enter-namespace $lxc /usr/sbin/dhclient $VIF_GUEST

735 else

736 post_install_myplc $lxc $personality

737 lxc_start $lxc

738 wait_for_ssh $lxc

739 fi

740 # setup localtime from the host

741 cp /etc/localtime $rootfs_path/etc/localtime

742 }

743

744 function post_install_build () {

745

746 set -x

747 set -e

748 trap failure ERR INT

749

750 lxc=$1; shift

751 personality=$1; shift

752

753 ### From myplc-devel-native.spec

754 # be careful to backslash $ in this, otherwise it's the root context that's going to do the evaluation

755 cat << EOF | chroot $rootfs_path /bin/bash -x

756 # set up /dev/loop* in lxc

757 for i in \$(seq 0 255) ; do

758 /bin/mknod -m 640 /dev/loop\$i b 7 \$i

759 done

760

761 # create symlink for /dev/fd

762 [ ! -e "/dev/fd" ] && /bin/ln -s /proc/self/fd /dev/fd

763

764 # modify /etc/rpm/macros to not use /sbin/new-kernel-pkg

765 /bin/sed -i 's,/sbin/new-kernel-pkg:,,' /etc/rpm/macros

766 if [ -h "/sbin/new-kernel-pkg" ] ; then

767 filename=\$(/bin/readlink -f /sbin/new-kernel-pkg)

768 if [ "\$filename" == "/sbin/true" ] ; then

769 /bin/echo "WARNING: /sbin/new-kernel-pkg symlinked to /sbin/true"

770 /bin/echo "\tmost likely /etc/rpm/macros has /sbin/new-kernel-pkg declared in _netsharedpath."

771 /bin/echo "\tPlease remove /sbin/new-kernel-pkg from _netsharedpath and reintall mkinitrd."

772 exit 1

773 fi

774 fi

775

776 # customize root's prompt

777 /bin/cat << PROFILE > /root/.profile

778 export PS1="[$lxc] \\w # "

779 PROFILE

780

781 uid=2000

782 gid=2000

783

784 # add a "build" user to the system

785 builduser=\$(grep "^build:" /etc/passwd | wc -l)

786 if [ \$builduser -eq 0 ] ; then

787 groupadd -o -g \$gid build;

788 useradd -o -c 'Automated Build' -u \$uid -g \$gid -n -M -s /bin/bash build;

789 fi

790

791 # Allow build user to build certain RPMs as root

792 if [ -f /etc/sudoers ] ; then

793 buildsudo=\$(grep "^build.*ALL=(ALL).*NOPASSWD:.*ALL" /etc/sudoers | wc -l)

794 if [ \$buildsudo -eq 0 ] ; then

795 echo "build ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

796 fi

797 sed -i 's,^Defaults.*requiretty,#Defaults requiretty,' /etc/sudoers

798 fi

799 #

800 EOF

801

802 }

803

804 function post_install_myplc () {

805 set -x

806 set -e

807 trap failure ERR INT

808

809 lxc=$1; shift

810 personality=$1; shift

811

812 # be careful to backslash $ in this, otherwise it's the root context that's going to do the evaluation

813 cat << EOF | chroot $rootfs_path /bin/bash -x

814

815 # create /etc/sysconfig/network if missing

816 [ -f /etc/sysconfig/network ] || /bin/echo NETWORKING=yes > /etc/sysconfig/network

817

818 # create symlink for /dev/fd

819 [ ! -e "/dev/fd" ] && /bin/ln -s /proc/self/fd /dev/fd

820

821 # turn off regular crond, as plc invokes plc_crond

822 /sbin/chkconfig crond off

823

824 # take care of loginuid in /etc/pam.d

825 /bin/sed -i "s,#*$.*loginuid.*$,#\1," /etc/pam.d/*

826

827 # customize root's prompt

828 /bin/cat << PROFILE > /root/.profile

829 export PS1="[$lxc] \\w # "

830 PROFILE

831

832 EOF

833 }

834

835 function lxc_start() {

836

837 set -x

838 set -e

839 #trap failure ERR INT

840

841 lxc=$1; shift

842

843 virsh -c lxc:/// start $lxc

844

845 return 0

846 }

847

848 function wait_for_ssh () {

849 set -x

850 set -e

851 #trap failure ERR INT

852

853 lxc=$1; shift

854

855 echo $IP is up, waiting for ssh...

856

857 #wait max 5 min for sshd to start

858 ssh_up=""

859 stop_time=$(($(date +%s) + 300))

860 current_time=$(date +%s)

861

862 counter=1

863 while [ "$current_time" -lt "$stop_time" ] ; do

864 echo "$counter-th attempt to reach sshd in container $lxc ..."

865 ssh -o "StrictHostKeyChecking no" $IP 'uname -i' && { ssh_up=true; echo "SSHD in container $lxc is UP"; break ; } || :

866 sleep 10

867 current_time=$(($current_time + 10))

868 counter=$(($counter+1))

869 done

870

871 # Thierry: this is fatal, let's just exit with a failure here

872 [ -z $ssh_up ] && { echo "SSHD in container $lxc is not running" ; exit 1 ; }

873 return 0

874 }

875

876 ####################

877 function failure () {

878 echo "$COMMAND : Bailing out"

879 exit 1

880 }

881

882 function usage () {

883 set +x

884 echo "Usage: $COMMAND_LBUILD [options] lxc-name"

885 echo "Usage: $COMMAND_LTEST [options] lxc-name"

886 echo "Description:"

887 echo " This command creates a fresh lxc instance, for building, or running a test myplc"

888 echo "Supported options"

889 echo " -f fcdistro - for creating the root filesystem - defaults to $DEFAULT_FCDISTRO"

890 echo " -d pldistro - defaults to $DEFAULT_PLDISTRO"

891 echo " -p personality - defaults to $DEFAULT_PERSONALITY"

892 echo " -n hostname - the hostname to use in container - required with $COMMAND_LTEST"

893 echo " -r repo-url - used to populate yum.repos.d - required with $COMMAND_LTEST"

894 echo " -P pkgs_file - defines the set of extra pacakges"

895 echo " by default we use vtest.pkgs or devel.pkgs according to $COMMAND"

896 echo " -v be verbose"

897 exit 1

898 }

899

900 ### parse args and

901 function main () {

902

903 #set -e

904 #trap failure ERR INT

905

906 if [ "$(id -u)" != "0" ]; then

907 echo "This script should be run as 'root'"

908 exit 1

909 fi

910

911 case "$COMMAND" in

912 $COMMAND_LBUILD)

913 BUILD_MODE=true ;;

914 $COMMAND_LTEST)

915 TEST_MODE=true;;

916 *)

917 usage ;;

918 esac

919

920 echo 'build mode=' $BUILD_MODE 'test mode=' $TEST_MODE

921

922 # the set of preinstalled packages - depends on vbuild or vtest

923 if [ -n "$BUILD_MODE" ] ; then

924 PREINSTALLED=devel.pkgs

925 else

926 PREINSTALLED=vtest.pkgs

927 fi

928 while getopts "f:d:p:n:r:P:v" opt ; do

929 case $opt in

930 f) fcdistro=$OPTARG;;

931 d) pldistro=$OPTARG;;

932 p) personality=$OPTARG;;

933 n) GUEST_HOSTNAME=$OPTARG;;

934 r) REPO_URL=$OPTARG;;

935 P) PREINSTALLED=$OPTARG;;

936 v) VERBOSE=true; set -x;;

937 *) usage ;;

938 esac

939 done

940

941 shift $(($OPTIND - 1))

942

943 # parse fixed arguments

944 [[ -z "$@" ]] && usage

945 lxc=$1 ; shift

946

947 # check we've exhausted the arguments

948 [[ -n "$@" ]] && usage

949

950 [ -z "$fcdistro" ] && fcdistro=$DEFAULT_FCDISTRO

951 [ -z "$pldistro" ] && pldistro=$DEFAULT_PLDISTRO

952 [ -z "$personality" ] && personality=$DEFAULT_PERSONALITY

953

954 if [ -n "$BUILD_MODE" ] ; then

955 [ -z "$GUEST_HOSTNAME" ] && GUEST_HOSTNAME=$lxc

956 else

957 [[ -z "$GUEST_HOSTNAME" ]] && usage

958 # use -r none to get rid of this warning

959 if [ "$REPO_URL" == "none" ] ; then

960 REPO_URL=""

961 elif [ -z "$REPO_URL" ] ; then

962 echo "WARNING -- setting up a yum repo is recommended"

963 fi

964 fi

965

966 ##########

967 release=$(echo $fcdistro | cut -df -f2)

968

969 if [ "$personality" == "linux32" ]; then

970 arch=i386

971 arch2=i686

972 elif [ "$personality" == "linux64" ]; then

973 arch=x86_64

974 arch2=x86_64

975 else

976 echo "Unknown personality: $personality"

977 fi

978

979 if [ -n "$BUILD_MODE" ] ; then

980

981 # Bridge IP affectation

982 byte=$(random_private_byte)

983 IP=${PRIVATE_PREFIX}$byte

984 NETMASK=$(masklen_to_netmask $PRIVATE_MASKLEN)

985 GATEWAY=$PRIVATE_GATEWAY

986 VIF_HOST="i$byte"

987 else

988 [[ -z "GUEST_HOSTNAME" ]] && usage

989

990 create_bridge_if_needed

991

992 IP=$(gethostbyname $GUEST_HOSTNAME)

993 # use same NETMASK as bridge interface br0

994 MASKLEN=$(ip addr show $PUBLIC_BRIDGE | grep -v inet6 | grep inet | awk '{print $2;}' | cut -d/ -f2)

995 NETMASK=$(masklen_to_netmask $MASKLEN)

996 GATEWAY=$(ip route show | grep default | awk '{print $3}')

997 VIF_HOST="i$(echo $GUEST_HOSTNAME | cut -d. -f1)"

998 fi

999

1000 echo "the IP address of container $lxc is $IP, host virtual interface is $VIF_HOST"

1001

1002 path=/vservers

1003 [ ! -d $path ] && mkdir $path

1004 rootfs_path=$path/$lxc/rootfs

1005 config_path=$path/$lxc

1006 cache_base=/var/cache/lxc/fedora/$arch

1007 cache=$cache_base/$release

1008 root_password=root

1009

1010 # check whether the rootfs directory is created to know if the container exists

1011 # bacause /var/lib/lxc/$lxc is already created while putting $lxc.timestamp

1012 [ -d $rootfs_path ] && \

1013 { echo "container $lxc already exists in filesystem - exiting" ; exit 1 ; }

1014 virsh -c lxc:/// domuuid $lxc >& /dev/null && \

1015 { echo "container $lxc already exists in libvirt - exiting" ; exit 1 ; }

1016

1017 setup_lxc $lxc $fcdistro $pldistro $personality

1018

1019 devel_or_vtest_tools $lxc $fcdistro $pldistro $personality

1020

1021 post_install $lxc $personality

1022

1023 echo $COMMAND Done

1024 }

1025

1026 main "$@"