#!/bin/bash
# Author: Ben Wong <ben@wongs.net>
# Created on: <2001-08-08 11:56:03 hackerb9>
# Time-stamp: <2002-11-20 14:13:11 bbb>
# onlogdo: a hack to handle a common problem: when a certain message
# shows up in the log file, an action should be performed. E.g.: when
# a PC-card network device is inserted, it should be ifconfig'd or
# perhaps dhclient should be run. This program can do that in a fairly
# reasonable way.
### FIRST, THE HELPER FUNCTIONS ###
function showmanpage () {
cat <<'EOF'
NAME
onlogdo - monitor a log file and execute commands based on patterns
SYNOPSIS
onlogdo <logfile> <pattern> <command>
[ <pattern> <command> ...
]
logfile: a file that gets appended to (e.g., /var/log/messages),
pattern: a string (can use bash's extended pathname globbing syntax),
command: the command to run when the previous pattern is seen.
DESCRIPTION
Onlogdo is a hack to handle a common problem: when a certain
message shows up in a log file, an action should be performed.
E.g.: when a PC-card network device is inserted, it should be
ifconfig'd or perhaps dhclient should be run. This program can do
that in a fairly reasonable way.
Onlogdo continuously reads lines as they are appended to a log
file. When a line matches a given pattern, the command associated
with that pattern is run in the background. The patterns
recognized are standard pathname globbing (*, ?, []) plus bash's
extended pattern matching (extglob) syntax (see bash(1)).
The log file is reopened properly, if the log file being read is
rotated. Also, since it blocks when waiting for new lines, onlogdo
takes up almost no CPU time.
PATTERN MATCHING SYNTAX
Don't worry about learning the pattern matching the first time you
read this manual; you'll rarely need it, unless you're anal about
being as succinct as possible. (Like the author).
The following is an excerpt from bash's man page; see bash(1) for
full details. In the following description, a pattern-list is a
list of one or more patterns separated by a |. Composite patterns
may be formed using one or more of the following sub-patterns:
* Matches any string, including the null string.
? Matches any single character.
[...] Matches any one of the enclosed characters. A pair of
characters separated by a hyphen denotes a range
expression. If the first character following the [ is a
! or a ^ then any character not enclosed is matched.
?(pattern-list)
Matches zero or one occurrence of the given patterns
*(pattern-list)
Matches zero or more occurrences of the given patterns
+(pattern-list)
Matches one or more occurrences of the given patterns
@(pattern-list)
Matches exactly one of the given patterns
!(pattern-list)
Matches anything except one of the given patterns
EXAMPLES
Pipelines are okay:
onlogdo /var/log/messages '*' 'sleep 5; echo olleH | rev'
Wildcards match filenames as usual in a command:
onlogdo /var/log/messages 'Segfault' 'rm /*.core'
Multiple pattern and command pairs are allowed:
onlogdo /var/log/messages \
'ep0 at pcmcia' '/etc/rc.d/dhclient start' \
'ep0 detached' '/etc/rc.d/dhclient stop' \
'wi0 at pcmcia' '/etc/rc.d/dhclient start' \
'wi0 detached' '/etc/rc.d/dhclient stop'
Bash's extended pathname globbing to do the same as above:
onlogdo /var/log/messages \
'@(ep|wi)[0-9] at pcmcia' '/etc/rc.d/dhclient start' \
'@(ep|wi)[0-9] detached' '/etc/rc.d/dhclient stop'
A useful example for NetBSD/hpcmips:
onlogdo /var/log/messages 'hpcapm: resume' 'sleep 1; xrefresh'
Under NetBSD/hpcmips-1.5.1, the X server screen is overwritten by the
console on an APM resume. I put the last "onlogdo" example in my
system xinitrc, so xrefresh will be run automatically. (The sleep
is there to wait for the console to finish junking up the screen).
SEE ALSO
tail(1), bash(1)
BUGS
If this had been written in Perl it would have used "normal"
regexp syntax instead of pathname expansion. Bash's extensions
make the patterns as powerful as regexps, but more recondite.
There is no (documented) way for a command to refer to specifics
in the line that matched. E.g., if the pattern was "@(ep|wi)0",
the command wouldn't know if the line contained ep0 or wi0.
The author has spent way too much time perfecting a kludge. No
matter what you're using onlogdo for, there's probably a more
"correct" way to do it. On the other hand, onlogdo is widely
applicable and easy to use, so at least you won't be wasting much
time while doing it the "wrong" way.
There should be a real man page.
AUTHOR
Ben Wong <Benjamin.Wong@cc.gatech.edu>
HISTORY
Onlogdo started life as a one line kludge to work around a bug in
the interaction between APM and the X server in NetBSD-1.5/hpcmips
in September of 2001.
EOF
}
### USAGE AND ARGUMENT SANITY CHECKING ###
if [[ $# -lt 3 ]]; then
showmanpage
exit 1
fi
# Emacs's syntax highlighting doesn't handle single ticks (') properly.
# Check if -v (verbose) flag was given.
if [[ "$1" == "-v" ]]; then
ifverbose=echo # Echo commands verbosely, if -v.
shift
else
ifverbose=: # Usually just run a no-op.
fi
# Make sure the log file is readable.
if [[ ! -r "$1" ]]; then
echo "onlogdo: \"$1\" is not readable" >&2
exit 1
fi
if [[ -d "$1" ]]; then
echo "onlogdo: \"$1\" is a directory" >&2
exit 1
fi
### SIGNAL HANDLING AND EXIT CLEANUP ###
# Run cleanup function when shell exits.
trap cleanup EXIT
cleanup () {
echo "onlogdo: cleaning up..." >&2
if [[ "$TAILPID" ]]; then
kill $TAILPID # Kill the bg tail process.
fi
rm -f "$PIPE" # Delete the named pipe.
rmdir "$PIPEDIR"
return 0
}
### MAIN ROUTINE STARTS HERE ###
# Don't expand wildcards in pattern arguments as filenames.
set -o noglob
# Use bash's extended pattern matching operators
shopt -s extglob
# Create a pipe to read the log file a line at a time;
# Use mktemp for security.
PIPEDIR=$(mktemp -d /tmp/onlogdo.XXXXXX)
PIPE="$PIPEDIR/$(echo $1 | sed 's#^/##; s#/#.#g')" # var.log.messages
rm -f $PIPE
mknod $PIPE p
tail -Fn0 $1 >$PIPE & # FSF tail: "tail --retry -fn0"
TAILPID=$!
exec 5< $PIPE
# Copy the positional paramaters in to a variable that can be indexed.
params=("$0" "$@")
# Repeatedly read from the pipe, process each line.
while :; do
while read REPLY <&5; do
$ifverbose -e "\nline: \"$REPLY\""
for ((i=2; i<$#; i+=2)); do
pattern=${params[$i]}
command=${params[$((i+1))]}
$ifverbose "pattern: \"$pattern\""
if [[ -z "${REPLY##*$pattern*}" ]]; then
$ifverbose "*MATCHED*"
$ifverbose "command: \"$command\""
set +o noglob # Allow pathname matching in commands
eval $command &
set -o noglob # No pathname expansion for patterns
fi
done
done
# We get here whenever the pipe first blocks (returns EOF)
sleep 1 # Don't loop too quickly
done
### MAIN ROUTINE ENDS HERE ###
# Note: if we ever get here, the cleanup() function will be called
# automatically since we're trapping on signal 0.
