#!/bin/bash -i

# A script to assist in exposing user-defined shell functions
# (not aliases) to utilities that only have access to the $PATH.
#
# Usage: create a symlink somewhere on your $PATH such that the
# name of the link is "run_" plus the name of the function to 
# be invoked.
#
# For example, if you define a function named update_confs
# and wish to expose this to other non-shell processes that don't know
# about shell functions, you would create on your $PATH a 
# symlink named run_update_confs, and when you execute that file, 
# this script will execute the update_confs  function, passing through
# any arguments that were submitted.
#
# If the function has output, it will be written to a file
# in /tmp/out (if the directory exists and is writable) with the 
# name of the function appended with '.out'.
#
# In the above example, output would be written to 
# /tmp/out/update_confs.out.
#
# If the directory does not exist or is not writable, output
# goes to /dev/null.


# The name of the link, which is also the name of the function
# to be executed.
command="$(basename $0)"

if [ ${#command} -lt 5 -o \
     "$(echo ${command} | cut -c 1-4)" != "run_" ]; then
  cat <<EOF
The name by which the exec_shell_function.sh script was
invoked does not have the correct format. The link name
should be of the form "run_funcname", where funcname is 
the name of the function that is to be invoked. This
script was invoked with the name "${command}".
EOF
  exit 1
fi

# Remove the run_ part of the command to get the name of
# the function to be run.
command="$(echo ${command} | cut -c 5-)"

# The type that this process sees for the given command. This
# should be "function", indicating that there is a function
# with the same name as this link and which will have
# precedence over this command (otherwise there would be infinite
# recursion).
command_type="$(type -type ${command})"

# Output directory to which output is written (in a linkname.out file),
# if the directory exists and is writable.
out_dir=/tmp/out

# Determine the output file to be used for std_err and std_out.
# If there is a writable directory named ${out_dir}, then
# we create and write to a file in that directory whose name
# is "${command}.out".
if [ -w ${out_dir} -a -d ${out_dir} ]; then
  out_file="${out_dir}/${command}.out"
  # Verify that if the out_file already exists it is writable,
  # and set it to /dev/null if that's not the case.
  if [ -e ${out_file} -a ! -w ${out_file} ]; then
    out_file=/dev/null
  fi
else
  out_file=/dev/null
fi

# Verify that this process sees the command as a function,
# in order to prevent going into an infinite loop by execting this link
# again.
if [ "${command_type}" != "function" ]; then
  cat <<EOF &> ${out_file}
Cannot find function with name "${command}". Exiting..
EOF
  exit 1
fi

echo "${command} $*" </dev/null &> ${out_file}
${command} $* </dev/null >> ${out_file} 2>> ${out_file}

exit 0