Sometimes you need to do a tail -f, grep the results, and then nuke the file and start all over again... wouldn't it be nice if you could just run a single command to do it, and optionally have it serve the output up on a port?
Example command line:
hotgrep /that/file/over.there '.+' 2000
Which will tail -f the file in a very cool way!
UNIX only.
This IS an intentionally stripped-down version which does not do EVERYTHING that anybody might want... it is here for didactic purposes only, but is fully functional as described. If somebody intends to modify this wiki page, I hope they will keep that in mind.
#!tclsh
;## coded by Phil Ehrens for LIGO/LDAS 09/29/99
;## a combined tail -f, and egrep wrapped in a server!
;## some experimental handling of HTML tags is
;## implemented.
;##
;## See sample client at end of script.
set msg " hotgrep command syntax:\n
hotgrep filename 'rx_pattern' \[delay in secs.\] \[server_port\]\n
Only filename and rx_pattern are required, refresh delay defaults
to 2 seconds, and a server will only be set up if you spec a port.
Remember to protect your regexp pattern with ''s to avoid shell
expansion!
See the script for an example client for the server version."
;## helpful hint
if { [ llength $argv ] < 2 } {
puts stderr $msg
exit;
}
;## server port configuration stub
proc cfg {cid addr port} {
fileevent $cid readable "handle $cid"
}
;## server port handler
proc handle {cid} {
puts $cid $::buffer
close $cid
set ::buffer {}
}
;## simple html filter
proc html { data } {
regsub -all {<[Ll][Ii]>} $data { * } data
regsub -all {<[Ii][Mm][Gg][^>]+>} $data {* } data
regsub -all {<[^>]+>} $data {} data
regsub -all {\\\}} $data \} data
regsub -all {\\\{} $data \{ data
return $data
}
;## manage memory usage, since otherwise things COULD
;## blow up!
proc truncateBuffer {} {
if { ! $::server } { return }
set lines [ split $::buffer "\n" ]
set length [ llength $lines ]
if { $length > 256 } {
set first [ expr { 256 - $length } ]
set last [ expr { $length - 1 } ]
set ::buffer [ join [ lrange $lines $first $last ] "\n" ]
} }
;## see if file was reopened during sleep
proc statFile {} {
file stat $::fname fstat
set inode $fstat(ino)
if { $inode != $::inode } {
catch { close $::fid; unset ::fid }
}
if { ! [ info exists ::fid ] } {
set ::fid [ open $::fname r ]
set ::inode $inode
puts "file \"$::fname\" opened as $::fid"
}
}
proc readWrite {} {
while { [ gets $::fid line ] >= 0 } {
if { [ regexp $::rx $line ] } {
set line [ html $line ]
if { $::server } {
append ::buffer "$line\n"
} else {
puts stdout $line
}
}
}
}
;## the hot-grepper! file does NOT need to exist
;## at startup. File can get nuked without a hiccup!
proc run {} {
truncateBuffer
if { [ file exists $::fname ] } {
statFile
readWrite
} else {
;## maybe the file got nuked? Handle it!
catch { close $::fid; unset ::fid }
}
;## and loop
after $::delay run
}
proc init {} {
if { [ info exists ::fname ] } { return }
;## default delay = 2 seconds
set ::delay 2000
set ::server 0
set ::buffer {}
set ::inode {}
set ::fname {}
set ::rx {}
;## read the command line ::argv
if { [ catch {
set ::fname [ lindex $::argv 0 ]
set ::rx [ lindex $::argv 1 ]
if { [ llength $::argv ] >= 3 } {
if { [ catch {
set ::delay [ expr { [ lindex $::argv 2 ] * 1000 } ]
} err ] } {
return -code error "\n$err\nDid you protect your regexp?\n"
}
}
;## if a port was specified, get the number.
if { [ llength $::argv ] == 4 } {
set server_port [ lindex $::argv 3 ]
}
;## if a port was specified, hook it up!
if { [ info exists server_port ] } {
set ::server 1
set cid [ socket -server cfg $server_port ]
puts "socket \"$server_port\" opened as $cid"
}
} err ] } {
return -code error "$err\n$msg"
}
run
}
;## MAIN
init
vwait enter-mainloop
;##~~~~~~snip~~~~~~
;## EXAMPLE CLIENT
proc client { host port } {
set sid [ socket $host $port ]
puts $sid {}
flush $sid
while { [ gets $sid line ] > 0 } { puts $line }
close $sid
after 3000 "client $host $port"
}
;## after 100 client $host $port
;## vwait enter-mainloop