Getting started with ACF development

For the impatient, download http://dev.alpinelinux.org/~ncopa/setup-acf-dev and execute as root.
The script will:
Set up a small alpine chroot environment
Set up a user in the environment with sudo access
Install needed applications like subversion, http server and vim
Configure the http server
Check out ACF modules from svn repository and install them in the environemt
Create a simple .vimrc with useful key binding
Create a simple script to enter the chroot
#!/bin/sh

# bootstrap an alpine installation and set up ACF development
# version 1.2

usage() {
        cat << EOF
usage: $(basename $0) TARGETDIR

The following environment variables are used:"

  WGET        path to wget program ($WGET)
  TAR         path to tar program ($TAR)
  MIRROR      alpine mirror ($MIRROR)
  BASE        name of alpine base package ($BASE)
  ACFUSER     non-root username to use in chroot (\$SUDO_USER)
  ACFSVN      svn repository base ($ACFSVN)
  MODULES     svn modules to checkout ($MODULES)
  CHROOT      chroot program. I.E 'linux32 chroot' ($CHROOT)
  PORT        port for mini_httpd ($PORT)
  http_proxy  proxy server ($http_proxy)

EOF
        exit 3
}

die () {
        echo "$@" >&2
        exit 3
}

# read args

# set up vars
: ${WGET:="/usr/bin/wget"}
: ${TAR:="/usr/bin/tar"}
: ${MIRROR:="http://dev.alpinelinux.org/alpine/v1.7"}
: ${ACFSVN:="svn://svn.alpinelinux.org/acf"}
: ${MODULES:="core alpine-baselayout"}
: ${BASE:="base.tar.bz2"}
: ${ACFUSER:="$SUDO_USER"}
: ${CHROOT:="chroot"}
: ${PORT:="80"}

target=$1
CHD="$CHROOT $target"
[ -n "$http_proxy" ] && PROXY="http_proxy=$http_proxy"
APPS="haserl make mini_httpd subversion sudo vim luafilesystem"

# main
[ -z "$target" ] && usage
[ "$target" = "/" ] && die "Bootstrapping Alpine to '/' is probably not a good idea. Aborting..."
[ `whoami` != root ] && die "This script needs to be run as root."

while ! getent passwd "$ACFUSER" >/dev/null 2>&1 && [ "$ACFUSER" != root ] ; do
        echo -n "Enter non-root username: "
        read ACFUSER
done

mkdir -p "$target"

echo ">>> Fetching $MIRROR/$BASE..."
sh -c "$PROXY $WGET -q -O - $MIRROR/$BASE | tar -C \"$target\" -jxv" \
        || die "Failed to fetch or unpack $BASE"

echo ">>> Creating missing dirs..."
for dir in proc sys dev home; do
        mkdir -p "$target/$dir"
done

echo ">>> Installing busybox links..."
# create fake /proc/self/exe
mkdir -p "$target/proc/self"
ln -s /bin/busybox "$target/proc/self/exe"
$CHD /bin/busybox --install -s
rm -r "$target/proc/self"

if [ -f /etc/resolv.conf ]; then
        echo ">>> Copying /etc/resolv.conf..."
        cp /etc/resolv.conf "$target/etc/"
fi

echo ">>> Setting up APK_PATH..."
mkdir -p "$target/etc/apk"
echo "APK_PATH=$MIRROR/apks" >> "$target/etc/apk/apk.conf"

if [ -n "$http_proxy" ]; then
        echo ">>> Setting up http_proxy..."
        sed -i -e '/^http_proxy=/d' "$target/etc/profile"
        echo "http_proxy=$http_proxy" >> "$target/etc/profile"
fi

echo ">>> Settig up user $ACFUSER..."
$CHD adduser -D $ACFUSER

echo ">>> Installing applications..."
$CHD /bin/sh -c "$PROXY apk_add $APPS"

echo ">>> Setting up $ACFUSER as passwordless sudo user..."
sed -i -e "/^$ACFUSER /d" "$target/etc/sudoers"
echo "$ACFUSER ALL=(ALL) NOPASSWD: ALL" >> "$target/etc/sudoers"

echo ">>> Setting up mini_httpd..."
sed -i -e "/^MINI_HTTPD.*/d" "$target/etc/conf.d/mini_httpd"
echo 'MINI_HTTPD_OPTS="-C /etc/mini_httpd.conf"
MINI_HTTPD_DOCROOT=/var/www/localhost/htdocs' \
        >> "$target/etc/conf.d/mini_httpd"
cat << EOF > "$target/etc/mini_httpd.conf"
nochroot
dir=/var/www/localhost/htdocs
user=nobody
logfile=/var/log/mini_httpd.log
cgipat=cgi-bin**
port=$PORT
EOF
$CHD mkdir -p /var/www/localhost
$CHD ln -sf /usr/share/acf/www /var/www/localhost/htdocs

for svnmod in $MODULES ; do
        echo ">>> Checking out ACF module $svnmod"
        $CHD su $ACFUSER -c "svn co $ACFSVN/$svnmod/trunk ~/$svnmod"
        echo ">>> Installing ACF module $svnmod"
        $CHD su $ACFUSER -c "cd ~/$svnmod && sudo make install"
done

echo ">>> Creating .vimrc..."
cat <<EOF > "$target/home/$ACFUSER/.vimrc"
noremap <F9> <C-C>:w<CR> :! sudo make install<CR>
inoremap <F9> <C-C>:w<CR> :! sudo make install<CR>
EOF

echo ">>> Creating enter-chroot script..."
cat <<EOF > "$target/enter-chroot"
dir=\$(dirname \$0)
mount --bind /proc \$dir/proc
echo "Entering ACF develmopment chroot. Type 'exit' or press ctrl-d to leave."
$CHROOT \$(dirname \$0) /bin/sh -c 'su -l $ACFUSER' 
echo "Left ACF development chroot."
umount \$dir/proc
EOF
chmod +x "$target/enter-chroot"

cat <<EOF
>>>
>>> Setup Completed. Enter the chroot environement with (as root):
>>>
>>>     $target/enter-chroot
>>>
>>> Once inside the chroot the privileges will drop to '$ACFUSER'.
>>> You can start and stop mini_httpd within chroot by executing:
>>>
>>>     sudo /etc/init.d/mini_httpd start
>>>     sudo /etc/init.d/mini_httpd stop
>>>
>>> You can specify the port in /etc/mini_httpd.conf
>>>
>>> Remember to install the acf module to activate changes:
>>>
>>>     sudo make install
>>>
EOF