gzpipe

#!/bin/sh

######################################################################
#
# GZPIPE - Making a Named Pipe Behaves as a Gzipping Filter
#
# USAGE: gzpipe [-t timeout] <named_pipe_to_use> [output_file]
#
# 1) create the named pipe <named_pipe_to_use> when unexists
# 2) read stream data from the named pipe
# 3) compress it with gzip
# 4) output to <output_file> (default: STDOUT)
# 5) remove the named pipe if the pipe is made by me
# However, the pipe will be disconnected by itself when the time will
# have been to <timeout>(default:600sec). That is not to forget to disconnect.
#
# Return: ==0 when succeed
#         !=0 when failed
#
# HOW TO APPLY THIS:
# * e.g., if you want to write the executing log of a shellscript into
#   a file which is gzipped, you can use commands as follow.
#    > touch /PATH/TO/LOG/DIR/logfile.gz
#    > chmod 600 /PATH/TO/LOG/DIR/logfile.gz
#    > gzpipe /tmp/named_pipe.$$ /PATH/TO/LOG/DIR/logfile.gz
#    > [ $? -eq 0 ] || { echo 'error!' 1>&2; exit 1; }
#    > exec 2>/tmp/named_pipe.$$
#    > set -xv
#
# NOTICE:
# * The pipe and my process will be erased when the caller process will
#   die.
# * If you want to set permission to the <output_file>, you should
#   make the <output_file> beforehand with the demanded permission.
# * The following command, which use redirection instead of the 2nd
#   argument works correctly at almost all host.
#    > gzpipe "named_pipe_to_use" > "output_file"
#   But it should not be written. Beause the redirection from a
#   background process will not probably be assumed. And performance
#   also will probably worse than "output_file" is as an argument.
#   However, the method has GREAT POSSIBILITIES. e.g., you can write
#   commands as follow.
#    > gzpipe "namedpipe" | zcat | tr 'A-Z' 'a-z' | grep error >error.log &
#    > while [ ! -p "namedpipe" ];do sleep 0; done # wait for creating the pipe
#    > exec 2>"namedpipe"
#    > (various commands which write into stderr)
#   That means, you can join various filters to fd=2 (stderr). Although
#   it is very tricky. ;-)
#
# Written by Shell-Shoccar Japan (@shellshoccarjpn) on 2020-12-06
#
# This is a public-domain software (CC0). It means that all of the
# people can use this for any purposes with no restrictions at all.
# By the way, We are fed up with the side effects which are brought
# about by the major licenses.
#
# The latest version is distributed at the following page.
# https://github.com/ShellShoccar-jpn/misc-tools
#
######################################################################

readonly DEFAULT_TIMEOUT=600


######################################################################
# Initial Configuration
######################################################################

# === Initialize shell environment ===================================
set -u
umask 0022
export LC_ALL=C
export PATH="$(command -p getconf PATH 2>/dev/null)${PATH+:}${PATH-}"
case $PATH in :*) PATH=${PATH#?};; esac
export UNIX_STD=2003  # to make HP-UX conform to POSIX

# === Define the functions for printing usage ========================
print_usage_and_exit () {
  cat <<-USAGE 1>&2
	Usage   : ${0##*/} [-t timeout] <named_pipe_to_use> [output_file]
	          * See the document at the source code of this command
	Version : 2020-12-06 02:51:43 JST
	USAGE
  exit 1
}


######################################################################
# Prepare Main Routine
######################################################################

# === Define functions ===============================================
# --- FUNC: Make a Temporary File ------------------------------------
# arg   : (none)
# ret   : 0 when succeeded
# stdout: path of the generated temporary file
LFs=$(printf '\\\n_');LFs=${LFs%_} # Use as a "\n" in s-command of sed
mktempf0() {
  # --- parameters, etc.
  num_of_digits=16  # Length of Random String
  n=10              # Max Times of Retrying
  chrs='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_'
                    # Available letters
  # --- call built-in mktemp if exists
  type mktemp >/dev/null 2>&1 && {
    mktemp -t tmp.${0##*/}.$$.XXXXXXXXXXXXXXXX
    return $?
  }
  # --- set the temporary directory
  Dir_tmp=$(set | grep -q ^TMPDIR= | sed 's/^[^=]\{1,\}=//');
  case "$Dir_tmp" in
    '') Dir_tmp='/tmp'      ;;
    /)  Dir_tmp=''          ;;
    *)  Dir_tmp=${Dir_tmp%/};;
  esac
  # --- mktemp loop
  while [ $n -ge 0 ]; do
    # --- Generate Ramdom string
    # calculate the number of words which required
    nw=$(echo "${num_of_digits}*l(${#chrs})/11.09+1" | # 11.09=ln(65536)
         bc -l                                       |
         sed 's/\..*$//'                             )
    # make a random hexadecimal digit
    if [ -c /dev/urandom ]; then
      hstr=$(dd if=/dev/urandom bs=2 count=$nw 2>/dev/null |
             od -A n -t x2 -v                              |
             tr 'abcdef ' 'ABCDEF\n'                       |
             tr -Cd 0123456789ABCDEF                       )
    else
      hstr=$( (ps -Ao pid,etime,pcpu,vsz; date)         |
             od -t d4 -A n -v                           |
             sed 's/[^0-9]\{1,\}/'"$LFs"'/g'            |
             grep '[0-9]'                               |
             tail -n 42                                 |
             sed 's/.*\(.\{8\}\)$/\1/g'                 |
             awk 'BEGIN{a=-2147483648;}                 #
                       {a+=$1;        }                 #
                  END  {                                #
                    srand(a);                           #
                    for(i=0;i<'$nw';i++){               #
                      printf("%02X",int(rand()*65536)); #
                    }                                   #
                  }'                                    )
    fi
    # make a random string from the hexadecimal digit
    s=$(echo "obase=${#chrs};ibase=16;$hstr"                     |
        bc                                                       |
        tr -d '\\\n'                                             |
        tr ' ' '\n'                                              |
        awk 'BEGIN  {for(i=1;i<'$num_of_digits';i++){print 0;}}  #
             /[0-9]/{print;                                   }' |
        awk 'BEGIN  {ORS="";                                     #
                     s="'"$chrs"'";                              #
                     for(i=0;i<length(s);i++){                   #
                       c[i]=substr(s,i+1,1);                     #
                     }                        }                  #
             /[0-9]/{print c[$0*1];           }'                 |
        tail -c $num_of_digits                                   )
    # --- Making the file path
    Path_target="${Dir_tmp}/tmp.${0##*/}.$$.$s"
    # --- Making the file
    (set -C; umask 177; : > "$Path_target") 2>/dev/null || {
      [ -f "$Path_target" ] && { n=$((n-1)); continue; }
      n=-1; break;
    }
    break
  done
  # --- print error message when failed to make a file
  case "$n" in -1) return 1;; esac
  # --- print the path of the file
  printf '%s\n' "$Path_target"
  # --- return successfully
  return 0
}


######################################################################
# Main Routine
######################################################################

# === Judge which I have started as a parent or a child ==============
while :; do
  case $#     in                               6) :;; *) check='p'; break;; esac
  pid=$$
  pid=$(ps -Ao pid,ppid | awk '$1=='$pid'{print $2*1}')
  case "$pid" in '') echo '*** Unexpected error (ps command)' 1>&2; break;; esac
  pid=$(ps -Ao pid,ppid | awk '$1=='$pid'{print $2*1}')
  case "$pid" in                            "$5") :;; *) check='p'; break;; esac
  check='c';break;
done

# ===== ROUTINE AS A PARENT ==========================================
case $check in 'p')
  #
  # --- make sure that gzip command exists ---------------------------
  type gzip >/dev/null 2>&1 || {
    printf '%s\n' "${0##*/}: gzip command is not found" 1>&2
    exit 1
  }
  #
  # --- exit trap (for parent) ---------------------------------------
  exit_trap() {
    set -- ${1:-} $?  # $? is set as $1 if no argument given
    trap '' EXIT HUP INT QUIT PIPE ALRM TERM
    rm -f "${namedpipe_to_del_by_myself:-}"
    trap -  EXIT HUP INT QUIT PIPE ALRM TERM
    exit $1
  }
  #
  # --- parse the arguments ------------------------------------------
  timeout=$DEFAULT_TIMEOUT
  case $#   in                              0) print_usage_and_exit;; esac
  case "$1" in
    -t) shift
        case $# in                          0) print_usage_and_exit;; esac
        printf '%s' "$1" | grep -q '[^0-9]' && print_usage_and_exit
        timeout=$1
        shift
        ;;
  esac
  case $#   in                   [12]) :;;  *) print_usage_and_exit;; esac
  case "$1" in                             '') print_usage_and_exit;; esac
  pipe=$1
  outfile=''
  case $# in 2) case "$2" in '') :;; *) outfile=$2;; esac;; esac
  case "$pipe" in                  "$outfile") print_usage_and_exit;; esac
  case "$pipe"    in -|/*|./*|../*) :;; *) pipe="./$pipe"      ;; esac
  case "$outfile" in -|/*|./*|../*) :;; *) outfile="./$outfile";; esac
  #
  # --- enable the exit trap -----------------------------------------
  trap 'exit_trap' EXIT HUP INT QUIT PIPE ALRM TERM
  #
  # --- investigate the caller process ID ----------------------------
  pid=$$
  pid=$(ps -Ao pid,ppid | awk '$1=='$pid'{print $2}')
  #
  # --- make the named pipe if required ------------------------------
  check=$(ls -l "$pipe" 2>/dev/null)
  case "$?$check" in
    [1-9]|[1-9][0-9]|[012][0-9][0-9]) # $?>0 && $check==''
       mkfifo -m 600 "$pipe"
       case $? in
         0)  :                                                          ;;
         *)  printf '%s\n' "${0##*/}: Can't make the named pipe" 1>&2
             exit_trap 2                                                ;;
       esac
       namedpipe_to_del_by_myself=$pipe
       ;;
    0[!0-9]*)                         # $?==0 && $check!=''
       case "$check" in
         p*) :                                                          ;;
         *) printf '%s\n' "${0##*/}: \"$pipe\" exists as another attribute" 1>&2
            exit_trap 3                                                 ;;
       esac
       ;;
    *) printf '%s\n' "${0##*/}: An error occured at executing ls command" 1>&2
       exit_trap 4
       ;;
  esac
  #
  # --- make stderr silent -------------------------------------------
  #exec 3>&2 2>/dev/null # fd3 is only available for debugging
  exec 2>/dev/null >&2 3>&2
  #
  # --- prepare for locking ------------------------------------------
  sleep 100 & # This is to wait that the child process is ready
  sleepjob_pid=$!
  #
  # --- exec the gzip piping script ----------------------------------
  case "${namedpipe_to_del_by_myself:-}" in
    '') check=0                               ;;
    *)  check=1; namedpipe_to_del_by_myself='';;
  esac
  "$0" "$pipe" "$outfile" "$check" "$sleepjob_pid" "$pid" "$timeout" &
  #
  # --- wait for starting of the gzip piping script ------------------
  wait "$sleepjob_pid" 2>/dev/null
  #
  # --- exit normally ------------------------------------------------
  exit_trap 0
;;

# ===== ROUTINE AS A CHILD ===========================================

'c')
  # This child process must be called with the arguments
  #   $1:namedpipe to read
  #   $2:file to write into
  #   $3:1 is set if the parent wants the child to delete $1 after using,
  #      otherwise 0
  #   $4:process ID to kill for resuming the parent process
  #   $5:process ID which this script waits for termination (caller PID)
  #   $6:timeout (seconds)
  #
  # --- validate the arguments ---------------------------------------
  case $# in      6) :;; *) echo '*** Invalid arguments'   1>&3; exit 10;; esac
  [ -p "$1" ] ||          { echo '*** Invalid argument #1' 1>&3; exit 11; }
  pipe=$1
  if [ -n "$2" ] && ([ ! -f "$2" ] || [ ! -w "$2" ]); then
    echo '*** Invalid argument #2' 1>&3
    exit 12
  fi
  file=$2
  case "$3" in [01]) :;; *) echo '*** Invalid argument #3' 1>&3; exit 13;; esac
  del_the_pipe=$3
  printf '%s\n' "$4" | grep -q '^[0-9]\+$' ||
                          { echo '*** Invalid argument #4' 1>&3; exit 14; }
  ppid=$4
  printf '%s\n' "$5" | grep -q '^[0-9]\+$' ||
                          { echo '*** Invalid argument #5' 1>&3; exit 15; }
  cpid=$5
  printf '%s\n' "$6" | grep -q '^[0-9]\+$' ||
                          { echo '*** Invalid argument #6' 1>&3; exit 16; }
  timeout=$6
  #
  # --- set exiting trap ---------------------------------------------
  exit_trap() {
    set -- ${1:-} $?  # $? is set as $1 if no argument given
    trap '' EXIT HUP INT QUIT PIPE ALRM TERM
    ret=$1
    # --- the gzipped pipe has been used or not? ---
    while [ -f "${gz_file:-}" ]; do
      check=$(cat "$gz_file")
      case "$check" in '') break;; esac
      ret=$check
      break
    done
    # --- terminate the remained processes ---
    kill -s TERM "${timerjob_pid:-}" "${timersleep_pid:-}"   \
                 "${gzippedpipingjob_pid:-}" "${gzip_pid:-}" \
                 "${pollingsleep_pid:-}"
    # --- delete the unnecessary files ---
    rm -f "${gz_file:-}"
    case $del_the_pipe in 1) rm -f "$pipe";; esac
    # --- finish ---
    trap -  EXIT HUP INT QUIT PIPE ALRM TERM
    exit $ret
  }
  trap 'exit_trap' EXIT HUP INT QUIT PIPE ALRM TERM
  #
  # --- tell the parent that I have started up -----------------------
  kill -s TERM "$ppid"
  #
  # --- make a temporary file ----------------------------------------
  gz_file=$(mktempf0)
  case $? in
    0) :                                                                 ;;
    *) printf '%s\n' "${0##*/}: Can't make a tempfile" 1>&3; exit_trap 18;;
  esac
  #
  # --- set my life time ---------------------------------------------
  case $timeout in
    0) :                                                                      ;;
    *) pid=$$
       { sleep $timeout; kill -s ALRM $pid; } &
       timerjob_pid=$!
       timersleep_pid=$(ps -Ao pid,ppid | awk '$2=='$timerjob_pid'{print $1}');;
  esac
  #
  # --- do the gzipped piping (hehave as a background job) -----------
  pid=$$
  case "$file" in
    '') { gzip <"$pipe"         ; echo $? >"$gz_file"; kill -s ALRM $pid; } & ;;
    *)  { gzip <"$pipe" >"$file"; echo $? >"$gz_file"; kill -s ALRM $pid; } & ;;
  esac
  gzippedpipingjob_pid=$!
  gzip_pid=$(ps -Ao pid,ppid | awk '$2=='${gzippedpipingjob_pid}'{print $1}')
    # TIPS: { gzip < namedpipe_which_is_received_nothing_yet; } &
    #       You cannot find the process ID of gzip yet. The reason is
    #       that the namedpipe which is received nothing yet prevent from
    #       starting the gzip command until the namedpipe get any data.
  #
  # --- wait for termination of the caller (is not the parent) process
  while :; do
    kill -0 $cpid >/dev/null 2>&1
    case $? in 0) :;; *) break;; esac
    sleep 1 &
    pollingsleep_pid=$!
    wait $pollingsleep_pid
  done
  exit_trap 0
;; esac