path: root/trunk/src/templatepkg

#!/bin/bash
#
# templatepkg v0.3: template maintenance script from simplepkg suite
#
# feedback: rhatto at riseup.net | gpl
# 
#  Templatepkg is free software; you can redistribute it and/or modify it under the
#  terms of the GNU General Public License as published by the Free Software
#  Foundation; either version 2 of the License, or any later version.
#
#  Templatepkg is distributed in the hope that it will be useful, but WITHOUT ANY
#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
#  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License along with
#  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
#  Place - Suite 330, Boston, MA 02111-1307, USA
#

COMMON="/usr/libexec/simplepkg/common.sh"
BASENAME="`basename $0`"

if [ -f "$COMMON" ]; then
  source $COMMON
  eval_config `basename $0`
else
  echo "error: file $COMMON found, check your `basename $0` installation"
  exit 1
fi

function usage {

  echo "usage: $BASENAME <option> <template> [arguments]"
  echo "options:"
  echo ""
  echo "  -c | --create: create a template from a jail; arguments are:"
  echo ""
  echo "      $BASENAME -u <template> [jail-root]"
  echo ""
  echo "  -u | --update: update a template from a jail; arguments are:"
  echo ""
  echo "      $BASENAME -u <template> [jail-root]"
  echo ""
  echo "  -a | --add: add files into a template; arguments for -a are:"
  echo ""
  echo "      $BASENAME -a <template> <file-name> [jail-root]"
  echo ""
  echo "      file-name: the file or directory to be added"
  echo "      jail-root: the jail under file-name is located"
  echo ""
  echo "  -d | --delete: delete files or folders from a template; arguments are:"
  echo ""
  echo "      $BASENAME -d <template> <file-name>"
  echo ""
  echo "  -s | --sync: sync a template working copy; arguments are:"
  echo ""
  echo "      $BASENAME -d <template>"
  echo ""
  echo "  in all cases (-c, -u and -a), jail-root defaults to /, if ommited"
  echo ""
  exit 1

}

function template_create {

  # create a new template
  # TODO: usar svn add $TEMPLATE_BASE ao inves de svn mkdir, etc?

  local template_base

  if  [ ! -d "$TEMPLATE_BASE" ]; then
    if use_svn && [ -d "`dirname $TEMPLATE_BASE`/.svn" ]; then
      cd `dirname $TEMPLATE_BASE`
      svn mkdir $TEMPLATE_BASE
    else
      mkdir -p $TEMPLATE_BASE
    fi
  fi

  touch $TEMPLATE.perms
  touch $TEMPLATE.template

  if use_svn && [ -d "$TEMPLATE_BASE/.svn" ]; then

    cd $TEMPLATE_BASE

    if ! svn_check $TEMPLATE.d; then
      svn mkdir $TEMPLATE.d
    fi

    if ! svn_check $TEMPLATE.s; then
      svn mkdir $TEMPLATE.s
    fi

    if ! svn_check $TEMPLATE.template; then
      svn add $TEMPLATE.template
    fi

    if ! svn_check $TEMPLATE.perms; then
      svn add $TEMPLATE.perms
    fi

  else
    mkdir $TEMPLATE.{d,s}
  fi

  template_update

}

function template_update {

  # update the template package list

  components="$TEMPLATE.template $TEMPLATE.perms $TEMPLATE.d $TEMPLATE.s"
  for component in $components; do
    if [ ! -a "$component" ]; then
      echo $BASENAME: template component not found: $component
      echo $BASENAME: please run $BASENAME -c before update a template
      exit 1
    fi
  done

  if [ ! -d "$ROOT/var/log/packages" ]; then
    echo $ROOT/var/log/packages: directory not found
    exit 1
  fi

  for package in `ls -1 $ROOT/var/log/packages/`; do
    pack=`package_name $package`
    if [ -f $TEMPLATE ]; then
      if ! `grep -v -e "^#" $TEMPLATE | cut -d : -f 1 | grep -q -e "^$pack\$"`; then
        package_name $package >> $TEMPLATE
      fi
    else
      package_name $package >> $TEMPLATE
    fi
  done

  # check if each package from the template is installed
  grep -v -e "^#" $TEMPLATE | cut -d : -f 1 | while read pack; do

    if [ ! -z "$pack" ]; then
      unset found
      for candidate in `ls $ROOT/var/log/packages/$pack* 2> /dev/null`; do
        candidate="`package_name $candidate`"
        if [ "$pack" == "$candidate" ]; then
          found="1"
          break
        fi
      done
      if [ "$found" != "1" ]; then
        # remove a non-installed package from the template
        sed "/^$pack$/d" $TEMPLATE | sed "/^$pack $/d" | sed "/^$pack:*/d" > $TEMPLATE.tmp
        cat $TEMPLATE.tmp > $TEMPLATE
        rm -f $TEMPLATE.tmp
      fi
    fi

  done

}

function template_add {

  # add a file in a template
  # usage: template_add <jail-root> <file>

  local info_commit

  mkdir -p $TEMPLATE_BASE.d

  if [ -z "$1" ] || [ -z "$2" ]; then
    return 1
  fi

  jail="/$1" 
  file="$2"

  if [ -a "$TEMPLATE_BASE.d/$file" ]; then
    if [ -d "$TEMPLATE_BASE.d/$file" ]; then

      echo $BASENAME: folder $file already on $TEMPLATE_BASE.d, checking for contents

      cd $jail
      for candidate in `find $file`; do
        if [ ! -a "$TEMPLATE_BASE.d/$candidate" ]; then
          mkdir -p $TEMPLATE_BASE.d/`dirname $candidate`
          cp -a $jail/$candidate $TEMPLATE_BASE.d/$candidate
          if use_svn; then
            ( cd $TEMPLATE_BASE.d && svn add $candidate )
            info_commit="yes"
          fi
        fi
      done

      if [ "$info_commit" == "yes" ]; then
        echo $BASENAME: please run jail-commit to add files under $file into the svn repository
      fi

    else
      echo $BASENAME: file $file already on $TEMPLATE_BASE.d
      exti 1
    fi
  else
    if [ -a "$jail/$file" ]; then

      mkdir -p $TEMPLATE_BASE.d/`dirname $file`/
      destination="`echo $TEMPLATE_BASE.d/$file | sed -e 's/\/$//'`"
      cp -a $jail/$file $destination
      if use_svn; then
        ( cd $TEMPLATE_BASE.d && svn add $file )
        echo $BASENAME: please run jail-commit to add $file into the svn repository
        true
      fi

    else
      echo $BASENAME: $jail/$file: file not found
      exit 1
    fi
  fi

}

function setroot {

  # set ROOT variable
  # usage: setroot <value1> <value2>
  
  if [ -z "$1" ]; then
    ROOT="/"
  else
    ROOT="$1"
  fi

}

# command line parsing

if [ -z "$2" ]; then
  usage
fi

search_template $2 --new
TEMPLATE="$TEMPLATE_BASE.template"

if [ "$1" == "-u" ] || [ "$1" == "--update" ]; then

  setroot $3
  template_create

elif [ "$1" == "-c" ] || [ "$1" == "--create" ]; then

  setroot $3
  template_update

elif [ "$1" == "-a" ] || [ "$1" == "--add" ]; then

  if [ -z "$3" ]; then
    usage
  else
    setroot $4
  fi

  template_add $ROOT $3

elif [ "$1" == "-d" ] || [ "$1" == "--delete" ]; then

  if [ -z "$3" ]; then
    usage
  else

    if [ -a "$TEMPLATE_BASE.d/$3" ]; then
      if use_svn; then
        cd $TEMPLATE_BASE
        svn del --force ./$3 || rm -rf ./$3
        echo $BASENAME: please run jail-commit to del $3 in the svn repository
      else
        rm -rf $TEMPLATE_BASE.d/$3
      fi
    fi

  fi

elif [ "$1" == "-s" ] || [ "$1" == "--sync" ]; then

  if use_svn; then
    if [ -d "$TEMPLATE_BASE.d/.svn" ]; then
      ( cd $TEMPLATE_BASE.d && svn update )
      true
    fi
  fi

else
  usage
fi