@

#!/bin/bash
# @, aka monkey-tail
# Licenced under the GNU GPLv2

###########################################################################
# Globals

SELF=$( basename $0 )
SELF_LONG=$0
SELF_VERSION="0.01"
SELF_AUTHOR="Lucas Martin-King"

###########################################################################
# Embedded help

# |start|<program>|start a program detached from a terminal|
# |run-once|<program>|only start a program if it isn't running|

# |config|[<variable> [<new value>]]|manage embedded settings|
# |list-variables||list all embedded settings|
# |set-variable|<variable> <new value>|set variable to new value|
# |get-variable|<variable>|get variable value|

# |list-externals||list the names of all embedded externals|
# |external-add|<origin>|add an external from origin|
# |external-update|<external> [<origin>]|update an external's code|
# |external-remove|<external>|remove external's code, keeping header|
# |external-append|<external> <file>|append code to external|
# |external-code|<external>|output external's code, without headers|
# |external-extract|<external>|output external's code, including headers|

# |list-requirements||list required system commands|
# |check-requirements||check if system has required commands|

# |disk-usage|<path>|show disk usage|
# |disk-hogs|<path>|show top 10 disk hogs|
# |disk-free|<path>|show free space|
# |mem-used||show used memory|
# |mem-free||show free memory|
# |mem-total||show total memory|
# |proc|<name or pid>|show process info|
# |proc-tree|<name or pid>|show process tree|
# |proc-files|<name or pid>|show process files|

###########################################################################
# Embedded settings

# :proc.fields=uname,tty=TTY,pid,pcpu,pmem,rss,comm:
# :disk.hogs.number=10:

###########################################################################
# Subcommands

_start () {
 require nohup
 [[ -z "$1" ]] && return
 ( nohup $* > /dev/null 2>&1 & ) > /dev/null 2>&1
}

_run-once () {
 require pidof
 pidof $1 || _start $*
}

_disk-usage () {
 require du
 local dir="."
 [[ ! -z "$1" ]] && dir=$1
 du -chs $1 | tail -n 1
}

_disk-hogs () {
 require du sort head cut printf xargs
 IFS="$(printf '\n\t')"
 if [[ ! -z "$1" ]] ; then
  [[ ! -d $1 ]] && exit 1
  [[ -d $1 ]] && cd $1
 fi 
 dirs="$( ls -A . )"
 du -sk $dirs | sort -nr | head -n $( _get-variable disk.hogs.number ) | cut -f 2 |
 xargs -i% du --max-depth=0 -h "%"
}

_disk-free () {
 require df
 local dir="."
 [[ ! -z "$1" ]] && dir=$1
 df -h $dir
}

_mem-free () {
 require free
 free -m | sed -n 3p | awk '{ print $4"M" }'
}

_mem-used () {
 require free
 free -m | sed -n 3p | awk '{ print $3"M" }'
}

_mem-total () {
 require free
 free -m | awk '/Mem:/ { print $2"M" }'
}

_proc () {
 require ps
 local opt="-C $1"
 local fields=$( _get-variable proc.fields )
 is_numeric $1 && opt="-p $1"
 [[ -z "$1" ]] && opt="-U $USER"
 ps -H -o $fields $opt
}

_proc-tree () {
 require pstree pidof
 for pid in $(pidof $1) ; do
  pstree -l $pid
 done
}

_proc-files () {
 require lsof
 local opt="-c $1"
 is_numeric $1 && opt="-p $1"
 lsof -f $opt | grep -v "/lib\|/usr/lib\|/usr/local/lib\| socket\| pipe\| anon_inode"
}

###########################################################################
# Helper commands

_help () {
 echo "Usage: $SELF <subcommand>"
 echo "   or: $SELF list-commands"
 echo "   or: $SELF help-on <subcommand>"
 exit 1
}

_version () {
 echo "$SELF, version $SELF_VERSION, by $SELF_AUTHOR"
 exit 0
}

_list-commands () {
 declare -F | cut -d ' ' -f 3 | grep "^_.*" | sed 's/^_//' | column
}

_help-on () {
 local cmd=$1
 grep "^# |$cmd|" $SELF_LONG | sed -e 's/# |//' -e 's/|$//' -e 's/|/\t/g'
}

_get-variable () {
 local var=$1
 grep "^# :$var=.*:$" $SELF_LONG | sed -e 's/# ://' -e 's/:$//' | cut -d '=' -f 2- | head -n 1
}

_set-variable () {
 local var val oldval file
 [[ ! -w $SELF_LONG ]] && die "$SELF is read only"
 var=$1
 val=$2
 var_exists $var || die "$var doesn't exist"
 oldval=$( _get-variable $var )

 [[ "$oldval" == "$val" ]] && exit 0

 [[ -z "$val" ]] && warn "new value is empty"

 echo "var: $var old: $oldval new: $val"

 sed -i.bak -e "s/# :$var=$oldval:/# :$var=$val:/" $SELF_REAL
}

_list-variables () {
 grep "^# :.*=.*:$" $SELF_LONG | sed -e 's/# ://' -e 's/:$//' | uniq
}

_config () {
 if [[ -z "$1" ]] ; then
  _list-variables
 fi
 if [[ ! -z "$1" ]] && [[ ! -z "$2" ]] ; then
  _set-variable ${1} ${2}
 fi
 _get-variable ${1}
}

_list-externals () {
 grep -n "^# {begin:.*:.*}" $SELF_LONG | cut -d ":" -f 3
}

_external () {
 local begins ends origin loc
 origin=$( ext_origin $1 )
 begins=$( ext_begins $1 )
 ends=$( ext_ends $1 )
 [[ "$begins" == "" || "$ends" == "" ]] && return 1
 loc=":"
 [[ $begins -gt $ends ]] && begins=$ends && loc="|"
 echo "${begins}${loc}${ends} ${origin}"
}

_external-code () {
 ext_code $1
}

_external-extract () {
 ext_header $1 $( ext_origin $1 )
 ext_code $1
 ext_footer $1
}

_external-remove () {
 local starts ends file

 starts=$( ext_begins $1 )
 ends=$( ext_ends $1 )

 [[ -z "$starts" || -z "$ends" ]] && die "Cannot find start or end of $1"
 is_numeric $starts || die "something is not right"
 is_numeric $ends || die "something is not right"
 [[ $ends -lt $starts ]] && return 1

 echo "Removing code of '$1' from $SELF_REAL"
 sed -i.bak -e "${starts},${ends}d" $SELF_REAL
}

_external-append () {
 local line=$( ext_ends $1 )
 local file=$2
 echo "Appending code from $file to $SELF_REAL"
 [[ -f "$file" && "$line" != "" ]] && ext_insert "$file" $line
}

_external-add () {
 local origin name tmpfile offset
 origin=$1
 [[ -f $origin ]] && origin=$( readlink -f $origin )
 name=$( basename $origin )

 echo $name

 ext_begins $name > /dev/null && die "An external already exists by that name"
 ext_ends $name > /dev/null && die "An external already exists by that name"

 echo "..."

 tmpfile=/tmp/$SELF.$$.ext.add.tmp

 echo $tmpfile

 echo > $tmpfile
 ext_header $name $origin >> $tmpfile
 ext_footer $name >> $tmpfile
 offset=$( grep -n "^# {end:.*}$" $SELF_LONG | tail -n 1 | cut -d ":" -f 1 )
 if [[ -z "$offset" ]] ; then
  offset=$( wc -l $SELF_LONG | cut -d ' ' -f 1 )
  let "offset = $offset - 5"
 fi
 ext_insert $tmpfile $offset && _external-update $name
}

_external-update () {
 local ext=$1
 local origin

 if ext_begins $ext > /dev/null && ext_ends $ext > /dev/null ; then
  origin=$( ext_origin $ext )
  [[ ! -z "$2" ]] && origin=$2
  [[ -z "$origin" ]] && die "Origin not set"

  echo "Using $origin as origin"

  local ofile

  if echo $origin | grep -q '\(http\(s\?\)\|ftp\)://' ; then
   ofile=/tmp/$SELF.$$.ext.tmp
   echo "Fetching from $origin, saving to $ofile"
   wget --no-verbose -nc --progress=dot -O $ofile $origin || die "Could not fetch properly"
  else
   ofile=$origin
  fi

  if [[ -f "$ofile" ]] ; then
   sed '1p' $ofile | grep -q "^# @$" || warn "$ofile doesn't have '# @' on the first line, is it an external?"
  else
   die "Cannot load $origin"
  fi

  local backup=/tmp/$SELF.$$.tmp
  cp $SELF_REAL $backup && echo "Backup of $SELF_REAL is at $backup"

  _external-remove $ext
  _external-append $ext $ofile
 else
  die "Cannot update '$ext' because I can't find it"
 fi
}

_list-requirements () {
 require uniq
 local reqs=$(grep '\srequire \(\w*\)\(\(\s*\)\(\w*\)\)*' $SELF | sed -e 's/require//g' -e 's/ /\n/g' | sort | uniq)
 echo $reqs
}

_check-requirements () {
 local reqs=$(_list-requirements)

 for req in ${reqs} ; do
  eval "require $req"
 done
}

###########################################################################
# Helper functions

catch_all () {
 case "$1" in
  '-v' | '-version' | '--version') _version ;;
  '-h' | '-help' | '--help') _help ;;
 esac

 [[ ! -z "$1" ]] && echo "Command '$1' does not exist"

 _help
}

fn_exists () {
 type $1 2> /dev/null | grep -q 'function'
}

is_numeric () {
 echo "$@" | grep -q -v "[^0-9]"
}

var_exists () {
 local var=$1
 grep -q "^# :$var=.*:$" $SELF_LONG
}

die () {
 echo "error: $1" 1>&2 && exit 1
}

warn () {
 echo "warning: $1" 1>&2
}

file_type () {
 [[ ! -f "$1" ]] && return 1
 file -b "$1" | cut -d "," -f 1
}

file_mime () {
 [[ ! -f "$1" ]] && return 1
 file -b -i "$1" | cut -d ";" -f 1
}

require () {
 for cmd in $@ ; do
  if [[ ! "$( command -v "$cmd" )" ]] ; then
   die "require $cmd"
  fi
 done
}

main () {
 require sed awk grep cut head tail readlink file

 SELF_REAL=$( readlink -f $SELF_LONG )
 [[ -z "$SELF_REAL" ]] && SELF_REAL=$SELF_LONG

 if fn_exists _$(basename $0) ; then
  CMD=$(basename $0)
 elif fn_exists _$1 ; then
  CMD=$1
  shift
 else
  catch_all $1
 fi

 _$CMD "$@"
}

ext_begins () {
 local ln=$( grep -n "# {begin:$1:.*}" $SELF_LONG | cut -d ':' -f 1 )
 [[ -z "$ln" ]] && return 1
 expr $ln + 1
}

ext_ends () {
 local ln=$( grep -n "# {end:$1}" $SELF_LONG | cut -d ':' -f 1 )
 [[ -z "$ln" ]] && return 1
 expr $ln - 1
}

ext_origin () {
 sed -n 's/# {begin:'${1}':\(.*\)}/\1/p' $SELF_LONG
}

ext_code () {
 local start end
 start=$( ext_begins $1 )
 end=$( ext_ends $1 )
 [[ -z "$start" || -z "$end" ]] && die "Cannot find start or end of $1"
 [[ $end -lt $start ]] && return 1
 sed -n "${start},${end}p" $SELF_LONG
}

ext_insert () {
 local file start
 file=$1
 start=$2
 sed -i.bak -e "${start} r ${file}" $SELF_REAL
}

ext_header () {
 echo "# {begin:$1:$2}"
}

ext_footer () {
 echo "# {end:$1}"
}

###########################################################################
# External commands

###########################################################################
# Program

main "$@"