layersnap_

#!/bin/bash

# layersnap
# 
# overlayfs- and rsync-based simple snapshots
#
# - ls_bootstrap is called at the EOF
# - ls_bootstrap calls parseRequest and calls the appropriate controller
# - controller uses helpers to do the job
#

#
# convention:
# - GlobalVariable
# - localVariable
#
# todo
# ubuntu 12.04 syntax
# $((2 ** 4))



##############
##############
##          ##
##  ROUTER  ##
##          ##
##############
##############


#
# status, prepare, snapshot, merge or restore?
#

ls_bootstrap() { # (request)
  # parse request parameters
  parseRequest $*
  
  # choose mode
  setMode
  if [ "$LSMode" == "0" ]
  then
    echo "Sorry, but your System is not capable of running layersnap."
    echo "Layersnap depends on overlayfs, which was included in kernel 3.18 and extended by support of multiple lower-layers in 4.0. Besides that, Ubuntu supports overlayfs partly since at least 12.04 and fully since at least 14.04"
    exit
  fi 

  # basic paths and vars
  TargetName="$(basename $TargetPath)"
  PoolPath="$(dirname $TargetPath)/.layersnap/$TargetName"
  DateFormat="+%s"
  DisplayDateFormat="+%d.%m.%Y %H:%M:%S"

  case $ACTION in

    # status
    status)
      if [ ! -d "$PoolPath" ]
      then
        echo "$TargetPath is not layersnapped."
      else
        ls_status
      fi
    ;;

    # snapshot
    snapshot)
      ls_snapshot
    ;;
    
    #merge
    merge)
      if [ -d "$PoolPath" ]
      then
        ls_merge
      else
        echo ERROR: $TargetPath is not layersnapped, so nothing to merge!
      fi
    ;;
    
    #restore
    restore)
      if [ -d "$PoolPath" ]
      then
        ls_restore
      else
        echo ERROR: $TargetPath is not layersnapped, so nothing to restore!
      fi
    ;;
  esac
}


###################
###################
##               ##
##  CONTROLLERS  ##
##               ##
###################
###################


# 
# show status and layers
#

ls_status() {
  setPoolVars
  
  # ensure target is mounted
  if [ ! "$PoolMounted" == "true" ]
  then
    ls_mount
    echo "layers have just been mounted."
  fi
  
  # display summerizing information
  echo "LAYERSNAP: $TargetPath consists of $(expr $LayerCount + 1) layers. $(pluralize "layer" $LayersAvailable) available."
  
  # show detailed inforamtion for each layer
  i=1
  for f in "$PoolPath/lower-"*
  do
    layerStatusLine $i $f
    i=$(expr $i + 1)
  done
  layerStatusLine $(expr $LayerCount + 1) $UpperPath upper
}

#
# mount pool
#

ls_mount() {
  # select mode
  case $LSMode in
    1)
      mount -t overlayfs -o rw,lowerdir="$LowerList",upperdir="$UpperPath" overlayfs "$TargetPath"
    ;;
    2)

    ;;
    3)
      mount -t overlay overlay -o rw,lowerdir="$LowerList",upperdir="$UpperPath",workdir="$WorkPath" "$TargetPath"
    ;;
  esac
}

#
# create new snapshot-layer
#
# - unmount layers, except for first snapshot 
# - make lower-layer from target- or form upper-directory (on first snapshot)
# - create new empty upper directory
# - remount layers
#

ls_snapshot() {
  setPoolVars

  # select mode
  case $LSMode in
    1)
      ls_snapshot_mode1_mode3
    ;;
    2)
      ls_snapshot_mode2
    ;;
    3)
      ls_snapshot_mode1_mode3
    ;;
  esac
}

ls_snapshot_mode1_mode3() {
  # initial or consecutive snapshot?
  if [ ! -d "$PoolPath" ]
  then
    # create pool dir
    mkdir -p "$PoolPath"
    
    # create workdir if mode3
    if [ "$LSMode" == "3" ]
    then
      mkdir "$WorkPath"
    fi
    
    # make target dir the mew lower dir
    mv    "$TargetPath" "$LowerPath"
    
    # create new target dir as mountpoint
    mkdir "$TargetPath"
  else
    # abort when trying to make a socend snapshot in mode1
    if [ "$LSMode" == "1" ]
    then
      echo "Sorry, your system only allows one snapshot."
      exit
    fi
    
    # unmount target dir
    umount "$TargetPath"
    
    # make target dir the mew lower dir
    mv    "$TargetPath" "$LowerPath"
  fi

  # create upper dir anyway
  mkdir "$UpperPath"
  
  # mount it
  ls_mount
}

ls_snapshot_mode2() {
  ls
}

#
# restore layer
#
# - let user select layer-Id to restore
# - merge layer-after-layer into lowest layer
# - make lowest layer the new target dir
# - clean up
#

ls_restore() {
  ls_status
  read -p "Snapshot ID to restore: " toLayerID

  umount "$TargetPath"
  rmdir  "$TargetPath"
    
  i=1
  for f in "$PoolPath/lower-"*; do
    # remember lowest layer and merge all upper layer into it
    if [ "$i" == 1 ]; then
      LowestPath="$f"
    else
      mergeLayersByPath "$f/" "$LowestPath"
    fi
    if [ "$i" == "$toLayerID" ]; then break; fi
    i=$(expr $i + 1)
  done
  
  mv "$LowestPath" "$TargetPath"
  rm -R "$PoolPath"
}


#
# merge layers
#
# - ask for layers to merge
# - merge
#

ls_merge() {
  ls_status
  
  read -p "Merge layers starting from: " fromLayerID
  read -p "Merge layers ending with: " toLayerID
  echo "All layers between and including layers $fromLayerID and $toLayerID will be merged into layer $toLayerID."
  read -p "Enter 'merge' to confirm: " confirmation
  if [ ! "$confirmation" == "merge" ]; then
    echo "aborting."
    #return 2
  fi
  
  # find toLayer-path
  setToLayerPath
  
  i=1
  for f in "$PoolPath/lower-"*
  do
    if [ "$i" -ge "$fromLayerID" ] && [ "$i" -lt "$toLayerID" ]
    then
      mergeLayersByPath $f $toLayerPath
    elif [ "$i" -ge "$toLayerID" ]
    then
      break
    fi
    i=$(expr $i + 1)
  done
  
  echo "done"
}


#############
#############
##         ##
## HELPERS ##
##         ##
#############
#############


# choose layersnap mode fitting the host-system
setMode() {
  # try to check by ubuntu-version first, then by kernel-version
  if [ "$(cat /etc/issue | grep -c Ubuntu)" -gt "0" ]
  then
    ubuntuMainVersion=$(cat /etc/lsb-release | grep DISTRIB_RELEASE | cut -c 17- | cut -d "." -f1)
    ubuntuSubVersion=$(cat /etc/lsb-release | grep DISTRIB_RELEASE | cut -c 17- | cut -d "." -f2)
  else
    kernelMainVersion=$(uname -r | cut -d "." -f1)
    kernelSubVersion=$(uname -r | cut -d "." -f2)
  fi
  
  if [ "$ubuntuMainVersion" -ge "14" ] && [ "$ubuntuSubVersion" -ge "04" ]
  then
    LSMode="2"
  elif   [ "$ubuntuMainVersion" -ge "12" ] && [ "$ubuntuSubVersion" -ge "04" ]
  then
    LSMode="1"
  elif [ "$kernelMainVersion" == "4" ]
  then
    LSMode="2"
  elif [ "$kernelMainVersion" == "3" ]   && [ "$kernelSubVersion" -ge "18" ]
  then
    LSMode="1"
  else
    LSMode="0"
  fi

  # LSMode="1"
}

# get human readable total size of directory
sizeOfDir() { # (pathname)
  location=$(dirname $(realpath $1))
  name=$(basename $(realpath $1))
  sizeCachePath="$location/.size_of_$name"
  if [ ! -e "$sizeCachePath" ]
  then
    echo $(du -sch $1 | head -n 1 | cut -d "	" -f1 ) > $sizeCachePath
  fi
  echo "$(cat "$sizeCachePath")"
}

# output number and pluralized version of word if needed
pluralize() { # (word, count)
 echo "$2 $1$(if [ "$2" != "1" ]; then echo "s"; fi)"
}

# compose status line of layer
layerStatusLine() { # (count, path)
  if [ "$3" != "upper" ]
  then
    # lower layers
    LayerDate=$(date -d @$(basename $2 | cut -c 7-) "$DisplayDateFormat")
  else
    # upper layer
    LayerDate=$(printf "%${#LayerDate}s" "now")
  fi
  LayerFileCount=$(find $2 -type f | wc -l)
  echo "layer $(printf "%${#LayerCount}d" $1) from $LayerDate with $(sizeOfDir "$2") in $(pluralize "file" $LayerFileCount)"
}

# set all the variables needed for working with a layer-pool
setPoolVars() {
  # display "not " if Pool is not mounted
  if mount | grep $TargetPath > /dev/null
  then
    PoolMounted="true"
  else
    PoolMounted="false"
  fi

  # date in format suitable for use in pathname
  Now=$(date "$DateFormat")
  
  # whole path with date
  LowerPath="$PoolPath/lower-$Now"
  
  # path to upper dir
  UpperPath="$PoolPath/upper"
  
  # path to work dir
  WorkPath="$PoolPath/work"
  
  # total lower-layer-count
  LayerCount=$(find "$PoolPath" -name lower-* | wc -l)

  # ":"-seperated list of layer-paths
  LowerList=""
  for f in "$PoolPath/lower-"*
  do
    LowerList="$(realpath "$f"):$LowerList"
  done
  LowerList=${LowerList::-1}
  
  # calculate number of still available layers
  if [ "$LSMode" == "3" ]
  then
    LayersAvailable="Unlimited"
  else
    LayersAvailable=$(expr "$LSMode" - "$LayerCount")
  fi
}

# used by --merge
setToLayerPath() {
  i=1
  for f in "$PoolPath/lower-"*
  do
    if [ "$i" == "$toLayerID" ]
    then
      toLayerPath="$f"
      break
    fi
    i=$(expr $i + 1)
  done
}

# sets LowerList-variable 
setLowerList() { # (from-ID, to-ID)
  if [[ "$1" =~ "^[0-9]+$" ]] && [[ "$1" =~ "^[0-9]+$" ]]
  then
    from="$1";to="$2"
  else
    from="1";to="999999999"
  fi

  LowerList=""
  i=1
  for f in "$PoolPath/lower-"*
  do
    if [ "$i" >= "$from" ] && [ "$i" <= "$to" ]
    then
      LowerList="$(realpath "$f"):$LowerList"
    fi
    i=$(expr $i + 1)
  done
  LowerList=${LowerList::-1}
}

# merges one directory into another, overwriting existing files 
mergeLayersByPath() { # (fromLayerPath, toLayerPath)
  echo "merging $1 into $2"
  rsync --remove-source-files "$1/"* "$2"
  # find "$1/"* -type d -empty -delete
  
  # displays message if layer has not been emptied and deleted completely
  rmdir "$1"
}

     
# parse request params
parseRequest() { # ()
  ACTION="status"
  while [[ $# -gt 1 ]]
  do
    key="$1"
    case $key in
      -m|--mount)
        ACTION="mount"
        shift
      ;;

      -s|--snapshot)
        ACTION="snapshot"
        shift
      ;;

      -c|--checkout)
        ACTION="checkout"
        shift
      ;;

      -r|--restore)
        ACTION="restore"
        shift
      ;;

      -m|--merge)
        ACTION="merge"
        shift
      ;;
    esac
  done

  # last param
  if [[ -n $1 ]]
  then
    TargetPath=$(realpath $1)
    #TargetPath="$(pwd)/$1"
  else
    echo "ERROR: please provide a target-dir!"
  fi
}


###############
###############
##           ##
## BOOTSTRAP ##
##           ##
###############
###############


# bootstrap and pass request params
ls_bootstrap $*