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=f16

15 DEFAULT_PLDISTRO=planetlab

16 DEFAULT_PERSONALITY=linux64

17 DEFAULT_IFNAME=eth0

19 COMMAND_VBUILD="vbuild-init-lxc.sh"

20 COMMAND_MYPLC="vtest-init-lxc.sh"

22 lxc_version="0.8.0-rc2"

24 function bridge_init () {

26 # turn on verbosity

27 set -x

29 # constant

30 INTERFACE_BRIDGE=br0

32 # Default Value for INTERFACE_LAN

33 INTERFACE_LAN=$(netstat -rn | grep '^0.0.0.0' | awk '{print $8;}')

36 echo "========== $COMMAND: entering start - beg"

37 hostname

38 uname -a

39 ifconfig

40 netstat -rn

41 echo "========== $COMMAND: entering start - end"

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

44 #

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

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

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

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

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

51 # take extra arg for ifname, if provided

52 [ -n "$1" ] && { INTERFACE_LAN=$1; shift ; }

54 #if we have already configured the same host_box no need to do it again

55 /sbin/ifconfig $INTERFACE_BRIDGE &> /dev/null && {

56 echo "Bridge interface $INTERFACE_BRIDGE already set up - $COMMAND start exiting"

57 return 0

58 }

59 /sbin/ifconfig $INTERFACE_LAN &>/dev/null || {

60 echo "Cannot use interface $INTERFACE_LAN - exiting"

61 exit 1

62 }

65 #Getting host IP/masklen

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

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

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

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

72 gateway=$(netstat -rn | grep '^0.0.0.0' | awk '{print $2;}')

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

75 # creating the bridge

76 echo "Creating bridge INTERFACE_BRIDGE=$INTERFACE_BRIDGE"

77 brctl addbr $INTERFACE_BRIDGE

78 #brctl stp $INTERFACE_BRIDGE yes

79 brctl addif $INTERFACE_BRIDGE $INTERFACE_LAN

80 echo "Activating promiscuous mode INTERFACE_LAN=$INTERFACE_LAN"

81 /sbin/ifconfig $INTERFACE_LAN 0.0.0.0 promisc up

82 sleep 2

83 echo "Setting bridge address=$address broadcast=$broadcast"

84 # static

85 #/sbin/ifconfig $INTERFACE_BRIDGE $address broadcast $broadcast up

86 dhclient $INTERFACE_BRIDGE

87 sleep 1

89 #Reconfigure the routing table

90 echo "Configuring gateway=$gateway"

91 route add default gw $gateway

93 echo "========== $COMMAND: exiting start - beg"

94 ifconfig

95 netstat -rn

96 echo "========== $COMMAND: exiting start - end"

99 return 0

100

101 }

102

103

104 function failure () {

105 echo "$COMMAND : Bailing out"

106 exit 1

107 }

108

109 function cidr_notation () {

110

111 netmask=$1; shift

112 cidr=0

113 for i in $(seq 1 4) ; do

114 part=$(echo $netmask | cut -d. -f $i)

115 case $part in

116 "255") cidr=$((cidr + 8));;

117 "254") cidr=$((cidr + 7));;

118 "252") cidr=$((cidr + 6));;

119 "248") cidr=$((cidr + 5));;

120 "240") cidr=$((cidr + 4));;

121 "224") cidr=$((cidr + 3));;

122 "192") cidr=$((cidr + 2));;

123 "128") cidr=$((cidr + 1));;

124 "0") cidr=$((cidr + 0));;

125 esac

126 done

127 echo $cidr

128

129 }

130

131 function check_yum_installed () {

132 package=$1; shift

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

134 }

135

136 function check_yumgroup_installed () {

137 group="$1"; shift

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

139 }

140

141 function prepare_host() {

142

143 #################### lxc-tools : rebuild as current fedora release has flaws

144 #install development tools

145 check_yumgroup_installed "Development Tools"

146 #install libcap-devel, libvirt

147 check_yum_installed libcap-devel

148 check_yum_installed libvirt

149

150 #retrieve and install lxc from sources

151 raw_version=$(lxc-version ||: )

152 lxc_installed_version=$(echo $raw_version | sed -e 's,.*: ,,')

153 if [ "$lxc_installed_version" != "$lxc_version" ] ; then

154 echo "Expecting version" '['$lxc_version']'

155 echo "Found version" '['$lxc_installed_version']'

156 echo "Installing lxc ..."

157 cd /root

158 [ -d lxc ] || git clone git://lxc.git.sourceforge.net/gitroot/lxc/lxc

159 cd lxc

160 git pull

161 git checkout $lxc_version

162 ./autogen.sh

163 ./configure --prefix=/usr --exec-prefix=/usr

164 make

165 make install

166 mkdir -p /usr/var/lib/

167 [ -d /usr/var/lib/lxc ] || ln -s /var/lib/lxc /usr/var/lib/lxc

168 cd $BUILD_DIR

169 fi

170

171 # #create a placeholder (just a hack to make lxc works)

172 # [ -d "/usr/local/var/lib" ] || mkdir -p /usr/local/var/lib

173

174 #################### bride initialization

175 check_yum_installed bridge-utils

176 #Bridge init

177 isInstalled=$(netstat -rn | grep '^0.0.0.0' | awk '{print $8;}')

178 if [ "$isInstalled" != "br0" ] ; then

179 bridge_init

180 sleep 5

181 fi

182

183 return 0

184 }

185

186

187

188 function configure_fedora() {

189

190 # disable selinux in fedora

191 mkdir -p $rootfs_path/selinux

192 echo 0 > $rootfs_path/selinux/enforce

193

194 # configure the network

195

196 cat <<EOF > ${rootfs_path}/etc/sysconfig/network-scripts/ifcfg-$IFNAME

197 DEVICE=$IFNAME

198 BOOTPROTO=static

199 ONBOOT=yes

200 HOSTNAME=$HOSTNAME

201 IPADDR=$IP

202 NETMASK=$NETMASK

203 GATEWAY=$GATEWAY

204 NM_CONTROLLED=no

205 TYPE=Ethernet

206 MTU=1500

207 EOF

208

209 # set the hostname

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

211 NETWORKING=yes

212 HOSTNAME=$HOSTNAME

213 EOF

214

215 # set minimal hosts

216 # cat <<EOF > $rootfs_path/etc/hosts

217 #127.0.0.1 localhost $HOSTNAME

218 #EOF

219

220 dev_path="${rootfs_path}/dev"

221 rm -rf $dev_path

222 mkdir -p $dev_path

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

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

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

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

227 mkdir -m 755 ${dev_path}/pts

228 mkdir -m 1777 ${dev_path}/shm

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

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

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

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

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

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

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

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

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

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

239

240 #echo "setting root passwd to $root_password"

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

242

243 return 0

244 }

245

246

247 function configure_fedora_init() {

248

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

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

251 chroot ${rootfs_path} chkconfig udev-post off

252 chroot ${rootfs_path} chkconfig network on

253 }

254

255

256 function configure_fedora_systemd() {

257

258 unlink ${rootfs_path}/etc/systemd/system/default.target

259 touch ${rootfs_path}/etc/fstab

260 chroot ${rootfs_path} ln -s /dev/null //etc/systemd/system/udev.service

261 chroot ${rootfs_path} ln -s /lib/systemd/system/multi-user.target /etc/systemd/system/default.target

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

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

264 chroot ${rootfs_path} chkconfig network on

265 }

266

267 function download_fedora() {

268 set -x

269 # check the mini fedora was not already downloaded

270 INSTALL_ROOT=$cache/partial

271 echo $INSTALL_ROOT

272 mkdir -p $INSTALL_ROOT

273 if [ $? -ne 0 ]; then

274 echo "Failed to create '$INSTALL_ROOT' directory"

275 return 1

276 fi

277

278 # download a mini fedora into a cache

279 echo "Downloading fedora minimal ..."

280 YUM="yum --installroot $INSTALL_ROOT -y --nogpgcheck --releasever=$release"

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

282

283

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

285 RELEASE_URL="$MIRROR_URL/Packages/fedora-release-$release-1.noarch.rpm"

286 echo "Fetching from $RELEASE_URL"

287 curl -f "$RELEASE_URL" > $INSTALL_ROOT/fedora-release-$release.noarch.rpm

288

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

290 rpm --root $INSTALL_ROOT --initdb

291 rpm --root $INSTALL_ROOT -ivh $INSTALL_ROOT/fedora-release-$release.noarch.rpm

292 echo "$YUM install $PKG_LIST"

293 $YUM install $PKG_LIST

294

295 if [ $? -ne 0 ]; then

296 echo "Failed to download the rootfs, aborting."

297 return 1

298 fi

299

300 mv "$INSTALL_ROOT" "$cache/rootfs"

301 echo "Download complete."

302

303 return 0

304 }

305

306

307 function copy_fedora() {

308 set -x

309 # make a local copy of the minifedora

310 echo -n "Copying rootfs to $rootfs_path ..."

311 mkdir -p $rootfs_path

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

313 return 0

314 }

315

316

317 function update_fedora() {

318 set -x

319 YUM="yum --installroot $cache/rootfs -y --nogpgcheck"

320 $YUM update

321 }

322

323

324 function install_fedora() {

325 set -x

326

327 mkdir -p /var/lock/subsys/

328 (

329 flock -n -x 200

330 if [ $? -ne 0 ]; then

331 echo "Cache repository is busy."

332 return 1

333 fi

334

335 echo "Checking cache download in $cache/rootfs ... "

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

337 download_fedora

338 if [ $? -ne 0 ]; then

339 echo "Failed to download 'fedora base'"

340 return 1

341 fi

342 else

343 echo "Cache found. Updating..."

344 update_fedora

345 if [ $? -ne 0 ]; then

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

347 else

348 echo "Update finished"

349 fi

350 fi

351

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

353 copy_fedora

354 if [ $? -ne 0 ]; then

355 echo "Failed to copy rootfs"

356 return 1

357 fi

358

359 return 0

360

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

362

363 return $?

364 }

365

366

367 function copy_configuration() {

368

369 mkdir -p $config_path

370 cat <<EOF >> $config_path/config

371 lxc.utsname = $lxc

372 lxc.arch = $arch2

373 lxc.tty = 4

374 lxc.pts = 1024

375 lxc.rootfs = $rootfs_path

376 lxc.mount = $config_path/fstab

377 #networking

378 lxc.network.type = $lxc_network_type

379 lxc.network.flags = up

380 lxc.network.link = $lxc_network_link

381 lxc.network.name = $IFNAME

382 lxc.network.mtu = 1500

383 lxc.network.ipv4 = $IP/$CIDR

384 lxc.network.veth.pair = $veth_pair

385 #cgroups

386 #lxc.cgroup.devices.deny = a

387 # /dev/null and zero

388 lxc.cgroup.devices.allow = c 1:3 rwm

389 lxc.cgroup.devices.allow = c 1:5 rwm

390 # consoles

391 lxc.cgroup.devices.allow = c 5:1 rwm

392 lxc.cgroup.devices.allow = c 5:0 rwm

393 lxc.cgroup.devices.allow = c 4:0 rwm

394 lxc.cgroup.devices.allow = c 4:1 rwm

395 # /dev/{,u}random

396 lxc.cgroup.devices.allow = c 1:9 rwm

397 lxc.cgroup.devices.allow = c 1:8 rwm

398 lxc.cgroup.devices.allow = c 136:* rwm

399 lxc.cgroup.devices.allow = c 5:2 rwm

400 # rtc

401 lxc.cgroup.devices.allow = c 254:0 rwm

402 lxc.cgroup.devices.allow = b 255:0 rwm

403 EOF

404

405

406

407 cat <<EOF > $config_path/fstab

408 proc $rootfs_path/proc proc nodev,noexec,nosuid 0 0

409 devpts $rootfs_path/dev/pts devpts defaults 0 0

410 sysfs $rootfs_path/sys sysfs defaults 0 0

411 EOF

412 if [ $? -ne 0 ]; then

413 echo "Failed to add configuration"

414 return 1

415 fi

416

417 return 0

418 }

423 # overwrite lxc's internal yum config

424 function configure_yum_in_lxc () {

425 set -x

426 set -e

427 trap failure ERR INT

428

429 lxc=$1; shift

430 fcdistro=$1; shift

431 pldistro=$1; shift

432

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

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

435

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

437 [fedora]

438 name=Fedora $release - \$basearch

439 baseurl=http://mirror.onelab.eu/fedora/releases/$release/Everything/\$basearch/os/

440 enabled=1

441 metadata_expire=7d

442 gpgcheck=1

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

444

445 [updates]

446 name=Fedora $release - \$basearch - Updates

447 baseurl=http://mirror.onelab.eu/fedora/updates/$release/\$basearch/

448 enabled=1

449 metadata_expire=7d

450 gpgcheck=1

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

452 EOF

453

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

455 # just mention 'none' as the repo url

456 if [ -n "$MYPLC_MODE" -a "$REPO_URL" != "none" ] ; then

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

458 echo "WARNING : cannot create myplc repo"

459 else

460 # exclude kernel from fedora repos

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

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

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

464 done

465 # the build repo is not signed at this stage

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

467 [myplc]

468 name= MyPLC

469 baseurl=$REPO_URL

470 enabled=1

471 gpgcheck=0

472 EOF

473 fi

474 fi

475 }

476

477 # return yum or debootstrap

478 function package_method () {

479 fcdistro=$1; shift

480 case $fcdistro in

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

482 lenny|etch) echo debootstrap ;;

483 *) echo Unknown distro $fcdistro ;;

484 esac

485 }

486

487 # return arch from debian distro and personality

488 function canonical_arch () {

489 personality=$1; shift

490 fcdistro=$1; shift

491 case $(package_method $fcdistro) in

492 yum)

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

494 debootstrap)

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

496 *)

497 echo Unknown-arch-3 ;;

498 esac

499 }

500

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

502 function almost_empty () {

503 dir="$1"; shift ;

504 # non existing is fine

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

506 # need to have at most one file

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

508 }

509

510 function setup_lxc() {

511

512 set -x

513 set -e

514 #trap failure ERR INT

515

516 lxc=$1; shift

517 fcdistro=$1; shift

518 pldistro=$1; shift

519 personality=$1; shift

520

521 # create lxc container

522 copy_configuration

523 if [ $? -ne 0 ]; then

524 echo "failed write configuration file"

525 exit 1

526 fi

527

528 install_fedora

529 if [ $? -ne 0 ]; then

530 echo "failed to install fedora"

531 exit 1

532 fi

533

534 configure_fedora

535 if [ $? -ne 0 ]; then

536 echo "failed to configure fedora for a container"

537 exit 1

538 fi

539

540 type /bin/systemd >/dev/null 2>&1

541 if [ $? -ne 0 ]; then

542 configure_fedora_init

543 else

544 configure_fedora_systemd

545 fi

546

547 # Enable cgroup

548 mkdir $rootfs_path/cgroup

549

550 # set up resolv.conf

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

552 # and /etc/hosts for at least localhost

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

554

555 # ssh access to lxc

556 mkdir $rootfs_path/root/.ssh

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

558

559 # start container

560 lxc-start -d -n $lxc

561

562 lxc-wait -n $lxc -s RUNNING

563

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

565

566 # wait max 5 min for sshd to start

567 ssh_up=""

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

569 current_time=$(date +%s)

570

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

572 echo "ssh attempt ..."

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

574 sleep 10

575 current_time=$(($current_time + 10))

576 done

577

578 [ -z $ssh_up ] && echo "SSHD in container $lxc is not running"

579

580

581 # rpm --rebuilddb

582 chroot $rootfs_path rpm --rebuilddb

583 #ssh -o "StrictHostKeyChecking no" $IP "rpm --rebuilddb"

584

585 configure_yum_in_lxc $lxc $fcdistro $pldistro

586

587 return 0

588 }

589

590 function devel_or_vtest_tools () {

591

592 set -x

593 set -e

594 trap failure ERR INT

595

596 lxc=$1; shift

597 fcdistro=$1; shift

598 pldistro=$1; shift

599 personality=$1; shift

600

601 pkg_method=$(package_method $fcdistro)

602

603 # check for .pkgs file based on pldistro

604 if [ -n "$VBUILD_MODE" ] ; then

605 pkgsname=devel.pkgs

606 else

607 pkgsname=vtest.pkgs

608 fi

609 pkgsfile=$(pl_locateDistroFile $DIRNAME $pldistro $pkgsname)

610

611 ### install individual packages, then groups

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

613

614 lxc_arch=$(chroot $rootfs_path uname -i)

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

616 [ "$lxc_arch" = "unknown" ] && lxc_arch=$(chroot $rootfs_path arch)

617

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

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

620

621 case "$pkg_method" in

622 yum)

623 [ -n "$packages" ] && chroot $rootfs_path yum -y install $packages

624 for group_plus in $groups; do

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

626 chroot $rootfs_path yum -y groupinstall "$group"

627 done

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

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

630 ;;

631 debootstrap)

632 chroot $rootfs_path apt-get update

633 for package in $packages ; do

634 chroot $rootfs_path apt-get install -y $package

635 done

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

637 ;;

638 *)

639 echo "unknown pkg_method $pkg_method"

640 ;;

641 esac

642

643 return 0

644 }

645

646 function post_install () {

647 if [ -n "$VBUILD_MODE" ] ; then

648 post_install_vbuild "$@"

649 else

650 post_install_myplc "$@"

651 fi

652 # setup localtime from the host

653 lxc=$1; shift

654 cp /etc/localtime $rootfs_path/etc/localtime

655 }

656

657 function post_install_vbuild () {

658

659 set -x

660 set -e

661 trap failure ERR INT

662

663 lxc=$1; shift

664 personality=$1; shift

665

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

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

668 cat << EOF | chroot $rootfs_path bash -x

669 # set up /dev/loop* in lxc

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

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

672 done

673

674 # create symlink for /dev/fd

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

676

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

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

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

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

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

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

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

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

685 exit 1

686 fi

687 fi

688

689 # customize root's prompt

690 cat << PROFILE > /root/.profile

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

692 PROFILE

693

694 uid=2000

695 gid=2000

696

697 # add a "build" user to the system

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

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

700 groupadd -o -g \$gid build;

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

702 fi

703

704 # Allow build user to build certain RPMs as root

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

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

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

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

709 fi

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

711 fi

712 #

713 EOF

714

715 }

716

717 function post_install_myplc () {

718 set -x

719 set -e

720 trap failure ERR INT

721

722 lxc=$1; shift

723 personality=$1; shift

724

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

726 cat << EOF | chroot $rootfs_path bash -x

727

728 # create /etc/sysconfig/network if missing

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

730

731 # create symlink for /dev/fd

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

733

734 # turn off regular crond, as plc invokes plc_crond

735 chkconfig crond off

736

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

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

739

740 # customize root's prompt

741 cat << PROFILE > /root/.profile

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

743 PROFILE

744

745 EOF

746 }

747

748 function usage () {

749 set +x

750 echo "Usage: $COMMAND_VBUILD [options] lxc-name"

751 echo "Usage: $COMMAND_MYPLC [options] lxc-name repo-url [ -- lxc-options ]"

752 echo "Description:"

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

754 echo "Supported options"

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

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

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

758 echo " -i ifname: determines ip and netmask attached to ifname, and passes it to the lxc"

759 echo "-- lxc-options"

760 echo " --netdev : interface to be defined inside lxc"

761 echo " --interface : IP to be defined for the lxc"

762 echo " --hostname : Hostname to be defined for the lxc"

763 echo "With $COMMAND_MYPLC you can give 'none' as the URL, in which case"

764 echo " myplc.repo does not get created"

765 exit 1

766 }

767

768 ### parse args and

769 function main () {

770

771 #set -e

772 #trap failure ERR INT

773

774 case "$COMMAND" in

775 $COMMAND_VBUILD)

776 VBUILD_MODE=true ;;

777 $COMMAND_MYPLC)

778 MYPLC_MODE=true;;

779 *)

780 usage ;;

781 esac

782

783 VERBOSE=

784 RESISTANT=""

785 IFNAME=""

786 LXC_OPTIONS=""

787 while getopts "f:d:p:i:" opt ; do

788 case $opt in

789 f) fcdistro=$OPTARG;;

790 d) pldistro=$OPTARG;;

791 p) personality=$OPTARG;;

792 i) IFNAME=$OPTARG;;

793 *) usage ;;

794 esac

795 done

796

797 shift $(($OPTIND - 1))

798

799 # parse fixed arguments

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

801 lxc=$1 ; shift

802 if [ -n "$MYPLC_MODE" ] ; then

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

804 REPO_URL=$1 ; shift

805 fi

806

807 # parse vserver options

808 if [[ -n "$@" ]] ; then

809 if [ "$1" == "--" ] ; then

810 shift

811 LXC_OPTIONS="$@"

812 else

813 usage

814 fi

815 fi

816

817 eval set -- "$LXC_OPTIONS"

818

819 while true

820 do

821 case "$1" in

822 --netdev) IFNAME=$2; shift 2;;

823 --interface) IP=$2; shift 2;;

824 --hostname) HOSTNAME=$2; shift 2;;

825 *) break ;;

826 esac

827 done

828

829

830 if [ -n "$VBUILD_MODE" ] ; then

831 [ -z "$IFNAME" ] && IFNAME=$DEFAULT_IFNAME

832 [ -z "$HOSTNAME" ] && HOSTNAME=$lxc

833 fi

834

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

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

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

838

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

840

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

842 arch=i386

843 arch2=x86

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

845 arch=x86_64

846 arch2=x86_64

847 else

848 echo "Unknown personality: $personality"

849 fi

850

851 # need lxc installed before we can run lxc-ls

852 # need bridge installed

853 prepare_host

854

855 if [ -n "$VBUILD_MODE" ] ; then

856

857 # Bridge IP affectation

858 x=$(echo $personality | cut -dx -f2)

859 y=$(echo $fcdistro | cut -df -f2)

860 z=$(($x + $y))

861

862 IP="192.168.122.$z"

863 NETMASK="255.255.255.0"

864 GATEWAY="192.168.122.1"

865

866 lxc_network_type=veth

867 lxc_network_link=virbr0

868 veth_pair="veth$z"

869 echo "the IP address of container $lxc is $IP "

870 else

871 [[ -z "$REPO_URL" ]] && usage

872 [[ -z "$IP" ]] && usage

873 NETMASK=$(ifconfig br0 | grep 'inet addr' | awk '{print $4}' | sed -e 's/.*://')

874 GATEWAY=$(route -n | grep 'UG' | awk '{print $2}')

875 [[ -z "$HOSTNAME" ]] && usage

876 lxc_network_type=veth

877 lxc_network_link=br0

878 veth_pair="i$(echo $HOSTNAME | cut -d. -f1)"

879 fi

880

881 CIDR=$(cidr_notation $NETMASK)

882

883

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

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

886 exit 1

887 fi

888

889 path=/var/lib/lxc

890 rootfs_path=$path/$lxc/rootfs

891 config_path=$path/$lxc

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

893 cache=$cache_base/$release

894 root_password=root

895

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

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

898 [ -d $rootfs_path ] && { echo "container $lxc already exists - exiting" ; exit 1 ; }

899

900 setup_lxc $lxc $fcdistro $pldistro $personality

901

902 devel_or_vtest_tools $lxc $fcdistro $pldistro $personality

903

904 post_install $lxc $personality

905

906

907 echo $COMMAND Done

908 }

909

910 main "$@"