source: tags/confman-1.0/confmanlib.sh @ 96

#! /bin/bash
#
# This file provides shell libraries to our configuration management system.
# It will be sourced by the relevant Rescomp scripts.
# 
# Author: Chris Cowart <ccowart@rescomp.berkeley.edu>
# Date: 30 March 2006
#
# $Id$

REPO_URI="${REPO_PROTOCOL}${REPO_HOSTNAME}${REPO_PATH}"

# Checks out the conf tree if we don't already have it. Updates it if we do.
function conf_checkout_tree {
  if [ ! -d ${WORK_PATH} ] ; then
       local path=`echo ${WORK_PATH} | sed -E 's:/[^/]+$::'`
       mkdir -p ${WORK_PATH}

       # This makes sure nobody can enter your working copy. We relax the
       # permissions during the rollout, and restrict them again at the end.
       chmod 700 ${WORK_PATH}

       svn checkout ${REPO_URI} ${WORK_PATH}
       rm -rf ${path}/.svn
  else
       svn update ${WORK_PATH}
  fi
}

# I update the working copy of a given module to the repository's copy.
function conf_update_module {
  local module="$1"
  svn update ${WORK_PATH}/${module}
}

# Updates the whole source tree
function conf_update_tree {
  svn update ${WORK_PATH}
}

# Revert a working file
function conf_revert {
  svn revert $*
}

# Assumes that we already have core setup in our work path.
function conf_create_module {
  local module=$1
  svn mkdir ${WORK_PATH}/$module
  svn mkdir ${WORK_PATH}/${REPO_CHECKPTS}/$module
  svn commit ${WORK_PATH}/${module} ${WORK_PATH}/${REPO_CHECKPTS}/$module -m \
      "Created directory structure for ${module} --`whoami`"
}

# Commits module $1 with message $2
function conf_commit {
  local module=$1
  local msg="$2"
  svn commit -F "$msg" ${WORK_PATH}/$module
}

# A way to utilize the svn status feature.
function conf_status {
  svn status $*
}

# Roll out the specified module, optionally at the specified checkpoint
# eg:  conf_rollout MODULE [checkpoint]
function conf_rollout {
  local module="$1"
  if [ -z $2 ] ; then
          local moduledir="${WORK_PATH}/$module"
  else 
          local moduledir="${WORK_PATH}/checkpoints/${module}/${2}"
  fi
  # This is a hack to work around NFS home dirs, for now:
  chmod o+rx ${WORK_PATH}

  for directory in `find $moduledir -type d | grep -v "\.svn"` ; do
          local livedir=`echo $directory | sed "s:$moduledir::"`
          livedir="${LIVE_ROOT}${livedir}"
          if [ ! -d $livedir ] ; then
                  local owner=`conf_get_prop ${directory} owner`
                  local group=`conf_get_prop ${directory} group`
                  local mode=`conf_get_prop ${directory} mode`
                  local opts="-d -o $owner -g $group -m $mode"
                  local cmd="sudo install $opts $livedir"
                  echo $cmd
                  $cmd
          fi
  done
  for file in `find $moduledir -type f | grep -v "\.svn"` ; do
          local livefile=`echo "$file" | sed "s:$moduledir::"`
          local owner=`conf_get_prop ${file} owner`
          local group=`conf_get_prop ${file} group`
          local mode=`conf_get_prop ${file} mode`
          local opts="-Sp -o $owner -g $group -m $mode"
          local cmd="sudo install $opts $file ${LIVE_ROOT}$livefile"
          echo $cmd
          $cmd
  done
  # This is a hack to work around NFS home dirs, for now:
  chmod o-rx ${WORK_PATH}
}

function conf_install {
  local module="$1"
  shift
  local file=`abspath $1`
  shift
  local moduledir="${WORK_PATH}/$module"
  local livefile=`echo "$file" | sed -E "s:${WORK_PATH}/[^/]+::"`
  local pathmodule=`echo "$file" | sed -E "s:${WORK_PATH}/([^/]+).*:\1:"`
  local suffix
  livefile=`echo "$livefile" | sed -E "s:-${pathmodule}$::"`
  if [[ $SINGULARITIES =~ $livefile ]] ; then
          suffix="-${module}"
  fi
  livefile="${livefile}${suffix}"


  # See if it even exists
  file="${moduledir}${livefile}"
  if [ ! -f $file ] ; then
          return 0
  fi

  # If we got here, figure it out
  local owner=`conf_get_prop ${file} owner`
  local group=`conf_get_prop ${file} group`
  local mode=`conf_get_prop ${file} mode`
  local opts="-Sp -o $owner -g $group -m $mode"
  local cmd="sudo install $opts $file ${LIVE_ROOT}$livefile"

  chmod o+rx ${WORK_PATH}
  echo $cmd
  $cmd
  chmod o-rx ${WORK_PATH}

  if [ ! -z $1 ] ; then
          conf_install $module $*
  fi
}


function conf_list {
  local file=$1
  local module=`echo ${file#$WORK_PATH} | sed -E 's:/([^/]+)/.*:\1:'`
  local livefile=`echo ${file#$WORK_PATH} | sed -E 's:/([^/]+)/:/:'`
  local owner=`conf_get_prop ${file} owner`
  local group=`conf_get_prop ${file} group`
  local mode=`conf_get_prop ${file} mode`
  local comment=`conf_get_prop ${file} comment`
  echo -e "$mode\t$owner\t$group\t$comment\t\t$livefile"
}
  


# This function assembles the singularities:
function conf_assemble_sing {
  local file=$1
  local livefile="${LIVE_ROOT}${file}"
  local tmpfile=`mktemp -t confman` || exit 1
  local owner group mode flag livepart msg
  for layer in $LAYERS ; do
          livepart="${LIVE_ROOT}${file}-${layer}"
          myfile="${WORK_PATH}/${layer}/${file}-${layer}"
          if [ -f $myfile -a -f $livepart ] ; then
                  owner=`conf_get_prop ${myfile} owner`
                  group=`conf_get_prop ${myfile} group`
                  mode=`conf_get_prop  ${myfile} mode`
                  comment=`conf_get_prop  ${myfile} comment`
                  cat $livepart >> $tmpfile
                  sudo rm $livepart
                  flag=1
          fi
  done
  if [ ! -z $flag ] ; then
        local opts="-o $owner -g $group -m $mode"
        local cmd="sudo install $opts $tmpfile $livefile"
        echo $cmd
        $cmd
  fi
  rm -f $tmpfile
}

# This function generates a checkpoint called NAME for the given MODULE.
# eg: conf_new_checkpoint MODULE NAME
function conf_new_checkpoint {
  local module=$1
  local checkpoint=$2
  local chkpath="${WORK_PATH}/${REPO_CHECKPTS}/${module}/${checkpoint}"
  local revision=`svn info ${WORK_PATH} | awk '/Last Changed Rev:/ {print $4}'`
  echo $revision > $chkpath
  svn add $chkpath
  local msg="Created a checkpoint, ${checkpoint} for ${module} --`whoami`"
  svn commit ${WORK_PATH}/${REPO_CHECKPTS} -m "$msg"
}

# This function will remove the checkpoint NAME from MODULE.
# eg: conf_rm_checkpoint MODULE NAME
function conf_rm_checkpoint {
  local module=$1
  local checkpoint=$2
  local chkpath="${WORK_PATH}/${REPO_CHECKPTS}/${module}/${checkpoint}"
  svn rm ${chkpath}
  local msg="Removed the checkpoint ${checkpoint} from ${module} --`whoami`"
  svn commit ${WORK_PATH}/${REPO_CHECKPTS} -m "$msg"
}

# This function will restore the state of your module's working copy to the
# named checkpoint. eg: conf_rollback MODULE NAME
function conf_rollback {
  local module=$1
  local checkpoint=$2
  local clock=$3
  local modpath="${WORK_PATH}/${module}"
  local chkpath="${WORK_PATH}/${REPO_CHECKPTS}/${module}/${checkpoint}"
  local revision
  local date=`echo $checkpoint | sed -E 's:(....)(..)(..):\1-\2-\3:'`

  # Named checkpoint
  if [ -f "${chkpath}" ] ; then
        revision=`cat $chkpath`
  elif [ -z $clock ] ; then             # Time checkpoint
        revision="{${date}}"
  else
        clock=`echo $clock | sed -E 's#(..)(..)#\1:\2#'`
        revision="{${date}T${clock}}"
  fi

  svn update --revision $revision $modpath
}

# This function will print the value of the specified property to STDOUT
function conf_get_prop {
  local file=$1
  local prop=$2
  svn propget "confman:${prop}" ${file}
}

# This function will set the value of the specified property.
function conf_set_prop {
  local file=$1
  local prop=$2
  local value=$3
  svn propset "confman:${prop}" "${value}" ${file}
}

function conf_gen_file {
  local module=$1
  local file=$2
  local owner=$3
  local group=$4
  local mode=$5
  local comment="$6"
  local usefile=$7
  local myfile="${WORK_PATH}/${module}${file}"
  local warning="${comment} ${CONF_WARNING}"
  local morewarn="${comment} Managed under ${module} module."
  local revision="${comment} \$Id\$"
  echo $file

  if [ -z $usefile ] ; then
          echo -e "${warning}\n${morewarn}\n${revision}\n" > $myfile
  elif head -n 1 ${usefile} | grep '^#!' >/dev/null ; then
          awk "{if (NR==2) 
                     print \"\\n${warning}\\n${morewarn}\\n${revision}\\n\"\$0;
                else print \$0 }" ${usefile} > $myfile
  else
          echo -e "${warning}\n${morewarn}\n${revision}\n" > $myfile
          cat ${usefile} >> $myfile
  fi

  svn add $myfile
  svn ps svn:keywords "Id" $myfile
  conf_set_prop $myfile owner $owner
  conf_set_prop $myfile group $group
  conf_set_prop $myfile mode  $mode
  conf_set_prop $myfile comment "$comment"
}

function conf_rm_file {
  svn rm $*
}

function conf_mkdir {
  local directory=$1
  local owner=$2
  local group=$3
  local mode=$4
  local workdir="/"
  local directories=`echo "$directory" | sed 's:/: :g'`
  local dir

  for dir in $directories ; do
          workdir="${workdir}/${dir}"
          if [ ! -d ${workdir} ] ; then
                  echo svn mkdir ${workdir}
                  svn mkdir ${workdir}
                  conf_set_prop $workdir owner $owner
                  conf_set_prop $workdir group $group
                  conf_set_prop $workdir mode $mode
                  conf_set_prop $workdir comment "dir"
          fi
  done
}

function conf_rmmod {
  local module=$1
  svn rm ${WORK_PATH}/${module}
  svn rm ${WORK_PATH}/${REPO_CHECKPTS}/${module}
}

function conf_mv {
  local oldname=$1
  local newname=$2
  svn mv $oldname $newname
}

function conf_cp {
  local oldname=$1
  local newname=$2
  svn cp $oldname $newname
}

function conf_diff {
  svn diff $*
}

function conf_log {
  svn log $*
}

function conf_cleanexit {
  echo "Abort, Abort! Patience is a virtue." >&2
  rm -f /tmp/confman*

  # And in case we got an interrupt during a rollout, we still want the
  # permissions here to be in a consistent state.
  chmod 700 ${WORK_PATH}

  # And this clears any locks we may have created on our working copy:
  svn cleanup ${WORK_PATH}
  echo "All clean. Terminating." >&2

  if [ -z $1 ] ; then
        exit 1
  else
        exit $1
  fi

}