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
else
  echo "error: file $COMMON found, check your $BASENAME installation"
  exit 1
fi

function usage {

  echo "usage: $BASENAME <option> <template> [arguments]"
  echo "options are:"
  echo ""
  echo "  -c | --create: create a template from a jail or existing template:"
  echo ""
  echo "      $BASENAME -c <template> [jail-root|template-name]"
  echo ""
  echo "  -u | --update: update a template from a jail:"
  echo ""
  echo "      $BASENAME -u <template> [jail-root]"
  echo ""
  echo "  -a | --add: add files into a template:"
  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:"
  echo ""
  echo "      $BASENAME -d <template> <file-name>"
  echo ""
  echo "  -s | --sync: sync $BASE_CONF/templates working copy:"
  echo ""
  echo "      $BASENAME -s"
  echo ""   
  echo "  -e | --export: export $BASE_CONF/templates to a svn repository:"
  echo ""   
  echo "      $BASENAME -e <svn-repository>"
  echo ""   
  echo "  -i | --import: grab $BASE_CONF/templates from a svn repository:"   
  echo ""   
  echo "      $BASENAME -i <svn-repository>"
  echo ""   
  echo "  -r | --remove: remove a template:"   
  echo ""   
  echo "      $BASENAME -r <template-name>"
  echo ""   
  echo "  -l | --list: list templates:"   
  echo ""   
  echo "      $BASENAME -l [template-name]"
  echo ""   
  echo "  -p | --post-install: add or edit post-installation scripts:"
  echo ""   
  echo "      $BASENAME -p <template-name> <script-name>"
  echo ""   
  echo "  -t | --template-edit: edit template package list:"
  echo ""   
  echo "      $BASENAME -t <template-name>"
  echo ""   
  echo "  -h | --help: display this summary."   
  echo ""   
  echo "  for -c, -u and -a jail-root defaults to / if ommited"
  echo ""
  exit

}

function check_svn_repo {

  # check a svn repository URL
  # usage: set_svn_repo <repository>

  if [ ! -z "$1" ]; then
    if echo $1 | grep -q -v -e "^svn://"; then
      if echo $1 | grep -q -v -e "^svn+ssh://"; then
        if echo $1 | grep -q -v -e "^file://"; then
          echo $BASENAME: invalid repository URL $1
          return 1
        fi
      fi
    fi
  else
    echo $BASENAME: no repository defined
    return 1
  fi

}

function import_export_templates {

  # import from or export to $BASE_CONF in a svn repository
  # usage: template_export <import|export> <repository>

  local templates_folder basedir repository mode preposition

  if [ "$?" != 0 ]; then
    usage
    exit 1
  elif ! use_svn; then
    echo $BASENAME: simplepkg not configured to use svn
    exit 1
  fi

  templates_folder="$BASE_CONF/templates"
  basedir="$BASE_CONF"
  mode="$1"
  repository="$2"
  preposition="from"

  check_svn_repo $repository

  if [ ! -z "$2" ]; then

    if [ ! -d "$templates_folder/.svn" ]; then

      cd $basedir

      if [ "$mode" == "export" ]; then
        preposition="to"
        svn import templates/ $repository/ -m "initial import"
        if [ "$?" != "0" ]; then
          echo $BASENAME: export failed
          exit 1
        fi
      fi

      if [ -d "templates" ]; then
        mv templates templates.old
      fi

      svn checkout $repository templates

      if [ "$?" == "0" ]; then
        rm -rf templates.old
      else
        rm -rf templates
        mv templates.old templates
        echo $BASENAME: $mode failed
        exit 1
      fi

    else
      echo "$BASENAME: $templates_folder seens to be already $mode""ed $preposition $repository"
      exit 1
    fi

  fi

}

function template_create {

  # create a new template

  local template_base info_commit orig_template list

  if [ ! -d "`dirname $TEMPLATE_BASE`" ]; then

    echo Creating template `basename $TEMPLATE_BASE`...

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

  else
    echo $BASENAME: template `basename $TEMPLATE_BASE` already exists
    exit 1
  fi

  touch $TEMPLATE_BASE.perms
  touch $TEMPLATE_BASE.template

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

    cd $TEMPLATE_BASE

    if ! svn_check $TEMPLATE_BASE.d; then
      svn mkdir $TEMPLATE_BASE.d
      info_commit="yes"
    else
      mkdir -p $TEMPLATE_BASE.d
    fi

    if ! svn_check $TEMPLATE_BASE.s; then
      svn mkdir $TEMPLATE_BASE.s
      info_commit="yes"
    else
      mkdir -p $TEMPLATE_BASE.s
    fi

    if ! svn_check $TEMPLATE_BASE.template; then
      svn add $TEMPLATE_BASE.template
      info_commit="yes"
    fi

    if ! svn_check $TEMPLATE_BASE.perms; then
      svn add $TEMPLATE_BASE.perms
      info_commit="yes"
    fi

  elif use_svn && [ -d "$BASE_CONF/templates/.svn" ]; then

    mkdir $TEMPLATE_BASE.{d,s}
    cd $BASE_CONF/templates
    svn add `basename $TEMPLATE_BASE`
    info_commit="yes"

  else
    mkdir $TEMPLATE_BASE.{d,s}
  fi

  if [ -d "/$ROOT" ]; then
    template_update
  elif [ ! -z "$ROOT" ]; then

    # copy from an existing template

    if [ -d "$BASE_CONF/templates/$ROOT" ]; then
      orig_template="$BASE_CONF/templates/$ROOT"
    elif [ -d "$BASE_CONF/defaults/templates/$ROOT" ]; then
      orig_template="$BASE_CONF/defaults/templates/$ROOT"
    else
      return 1
    fi

    cat $orig_template/$ROOT.perms > $TEMPLATE_BASE.perms
    cat $orig_template/$ROOT.template > $TEMPLATE_BASE.template
      
    if use_svn && [ -d "$orig_template/.svn" ]; then

      cd `dirname $TEMPLATE_BASE`

      list="`ls $orig_template/$ROOT.d/ 2> /dev/null`"
      if [ ! -z "$list" ]; then
        echo Copying files to the new template...
        rsync -av --exclude=.svn $orig_template/$ROOT.d/ $TEMPLATE_BASE.d/
        svn add `basename $TEMPLATE_BASE`.d/*
        info_commit="yes"
      fi

      list="`ls $orig_template/$ROOT.s/ 2> /dev/null`"
      if [ ! -z "$list" ]; then
        echo Copying scripts to the new template...
        rsync -av --exclude=.svn $orig_template/$ROOT.s/ $TEMPLATE_BASE.s/
        svn add `basename $TEMPLATE_BASE`.s/*
        info_commit="yes"
      fi

    else

      list="`ls $orig_template/$ROOT.d/ 2> /dev/null`"
      if [ ! -z "$list" ]; then
        echo Copying files to the new template...
        rsync -av $orig_template/$ROOT.d/ $TEMPLATE_BASE.d/
      fi

      list="`ls $orig_template/$ROOT.s/ 2> /dev/null`"
      if [ ! -z "$list" ]; then
        echo Copying scripts to the new template...
        rsync -av $orig_template/$ROOT.s/ $TEMPLATE_BASE.s/
      fi

    fi

  else
    echo $BASENAME: warning: no root directory defined
  fi

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

}

function template_update {

  # update the template package list

  check_template_exist

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

  echo Checking package list for template `basename $TEMPLATE_BASE`...

  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 | awk '{ print $1 }' | grep -q -e "^$pack\$"`; then
        echo $pack >> $TEMPLATE
        echo Added $pack # on $TEMPLATE
      fi
    else
      echo $pack >> $TEMPLATE
      echo Added $pack # on $TEMPLATE
    fi
  done

  # check if each package from the template is installed
  grep -v -e "^#" $TEMPLATE | cut -d : -f 1 | awk '{ print $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" | sed "/^$pack */d" > $TEMPLATE.tmp
        cat $TEMPLATE.tmp > $TEMPLATE
        rm -f $TEMPLATE.tmp
        echo Removed $pack from $TEMPLATE
      fi
    fi

  done

}

function template_add {

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

  local info_commit cwd

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

  check_template_exist

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

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

      echo $BASENAME: folder `slash $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 && [ -d "$TEMPLATE_BASE.d/.svn" ]; then
            cwd="`pwd`"
            cd $TEMPLATE_BASE.d
            svn add ./$candidate
            if [ "$?" != "0" ]; then
              echo $BASENAME: error adding `slash $candidate` into the revision system
            fi
            cd $cwd
            info_commit="yes"
          else
            echo Added `slash $jail/$candidate` on `slash $TEMPLATE_BASE.d/$candidate`
          fi
        fi
      done

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

    else
      echo $BASENAME: file `slash $file` already on $TEMPLATE_BASE.d
      exit 1
    fi
  else

    if [ -a "$jail/$file" ]; then

      destination="`echo $TEMPLATE_BASE.d/$file | sed -e 's/\/$//'`"

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

        if [ ! -d "$TEMPLATE_BASE.d/`dirname $file`/.svn" ]; then
          mkdir -p $TEMPLATE_BASE.d/`dirname $file`/
          svn add $TEMPLATE_BASE.d/`dirname $file`/
        fi

        cp -a $jail/$file $destination

        cwd="`pwd`"
        cd $TEMPLATE_BASE.d
        svn add ./$file

        if [ "$?" != "0" ]; then
          echo $BASENAME: error adding `slash $candidate` into the revision system
        else
          echo "$BASENAME: please run 'jail-commit --all' to add `slash $file` into the svn repository"
        fi

        cd $cwd

      else

        mkdir -p $TEMPLATE_BASE.d/`dirname $file`/
        cp -a $jail/$file $destination
        echo Added `slash $jail/$file` on `slash $destination`

      fi

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

}

function check_template_exist {

  # check if a template exists

  local components

  components="$TEMPLATE_BASE.template $TEMPLATE_BASE.perms $TEMPLATE_BASE.d $TEMPLATE_BASE.s"

  if [ ! -d "`dirname $TEMPLATE_BASE`" ]; then
    echo $BASENAME: template not found
    exit 1
  fi

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

}

function template_delete {

  # delete a file from a template
  # usage: template_delete <file>

  if [ -a "$TEMPLATE_BASE.d/$1" ]; then
    if use_svn && [ -d "$TEMPLATE_BASE.d/.svn" ]; then
      cd $TEMPLATE_BASE.d
      svn del --force ./$1 || rm -rf ./$1
      echo "$BASENAME: please run 'jail-commit --all' to del $1 in the svn repository"
    else
      rm -rf $TEMPLATE_BASE.d/$1
      echo Removed $1 from $TEMPLATE_BASE.d
    fi
  else
    if [ ! -d "$TEMPLATE_BASE.d" ]; then
      echo $BASENAME: template folder $TEMPLATE_BASE.d not found
    else
      echo $BASENAME: file $1 not found at $TEMPLATE_BASE.d
    fi
    exit 1
  fi

}

function template_remove {

  # remove a template
  # usage: template_remove

  local basedir template

  basedir="`dirname $TEMPLATE_BASE`"
  template="`basename $basedir`"

  if [ ! -d "$basedir" ]; then
    echo $BASENAME: template $template does not exist
    exit 1
  fi

  if use_svn && [ -d "$basedir/.svn" ]; then
    cd $BASE_CONF/templates
    svn del --force $template
    if [ "$?" != "0" ]; then
      echo $BASENAME: error deleting template $template
    else
      svn commit -m "deleted $template"
      if [ "$?" != "0" ]; then
        echo $BASENAME: error commiting to svn repository
      fi
    fi
  else
    rm -rf $basedir
  fi

}

function template_list {

  # list templates
  # usage: template_list [template_name]

  local list

  # TODO: checar se ha /

  list="`ls $BASE_CONF/defaults/templates/$1 2> /dev/null`"
  if [ "$?" == "0" ]; then
    list="`echo $list | xargs`"
    echo "Default templates: $list"
  fi

  list="`ls $BASE_CONF/templates/$1 2> /dev/null`"
  if [ "$?" == "0" ]; then
    list="`echo $list | xargs`"
    echo "Custom templates: $list"
  fi

}

function template_post_install_edit {

  # add or edit a post-installation script
  # usage: template_post_install_edit <script-name>

  if [ -z "$1" ]; then
    echo $BASENAME: no template specified
    exit 1
  elif echo $1 | grep -q "/"; then
    echo $BASENAME: error: invalid script name $1
  fi

  if [ -f "$TEMPLATE_BASE.s/$1" ]; then
    sha1sum="`sha1sum $TEMPLATE_BASE.s/$1`"
    if [ ! -z "$EDITOR" ]; then
      $EDITOR $TEMPLATE_BASE.s/$1
    else
      vi $TEMPLATE_BASE.s/$1
    fi
    if [ "$sha1sum" != "`sha1sum $TEMPLATE_BASE.s/$1`" ]; then
      echo "$BASENAME: please run 'jail-commit --all' to send changes to the repository"
    fi    
  else

    if [ -d "$TEMPLATE_BASE.s" ]; then

      touch $TEMPLATE_BASE.s/$1
      chmod +x $TEMPLATE_BASE.s/$1

      if [ -d "$TEMPLATE_BASE.s/.svn" ]; then
        cd $TEMPLATE_BASE.s
        svn add $1
        echo "$BASENAME: please run 'jail-commit --all' to send the script to the repository"
      fi

      echo "$BASENAME: script created; run templatepkg -p `basename $TEMPLATE_BASE` $1 again to edit it"

    else
      echo $BASENAME: folder not found: $TEMPLATE_BASE.s
    fi

  fi

}

function template_edit {

  # edit a template package list
  # usage: template_edit

  if [ -f "$TEMPLATE_BASE.template" ]; then
    sha1sum="`sha1sum $TEMPLATE_BASE.template`"
    if [ ! -z "$EDITOR" ]; then
      $EDITOR $TEMPLATE_BASE.template
    else
      vi $TEMPLATE_BASE.template
    fi
    if [ "$sha1sum" != "`sha1sum $TEMPLATE_BASE.template`" ]; then
      echo "$BASENAME: please run 'jail-commit --all' to send changes to the repository"
    fi
  else
    echo $BASENAME: file not found: $TEMPLATE_BASE.template
  fi

}

function require {

  # requires a string
  # usage: require [string]

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

}

function setroot {

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

}

function slash {

  # remove additional slashes
  echo $1 | sed -e 's/\/\+/\//g'

}

# -----------------------------------------------------
#                       main
# -----------------------------------------------------

if [ ! -z "$2" ]; then
  search_template $2 --new
fi

TEMPLATE="$TEMPLATE_BASE.template"

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

  require $2
  setroot $3
  template_update

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

  require $2
  setroot $3
  template_create

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

  require $2

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

  template_add $ROOT $3

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

  require $2

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

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

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

elif [ "$1" == "-e" ] || [ "$1" == "--export" ]; then
 
  require $2 
  import_export_templates export $2

elif [ "$1" == "-i" ] || [ "$1" == "--import" ]; then

  require $2
  import_export_templates import $2

elif [ "$1" == "-r" ] || [ "$1" == "--remove" ]; then

  require $2
  template_remove

elif [ "$1" == "-l" ] || [ "$1" == "--list" ]; then

  template_list $2

elif [ "$1" == "-p" ] || [ "$1" == "--post-install" ]; then

  require $3
  template_post_install_edit $3

elif [ "$1" == "-t" ] || [ "$1" == "--template-edit" ]; then

  require $2
  template_edit

elif [ "$1" == "-h" ] || [ "$1" == "--help" ]; then

  usage

else
  usage
fi