Just run this as your "capture" script.

#!/usr/bin/perl
use strict;
use Tk;
use IO::Handle;

my $H=IO::Handle->new;
open($H,"tail -f -n 1 test.dat |") or die $!;

my $main = MainWindow->new;

my $t = $main->Text(
              -wrap=>'none',
          -height => 2,
          )->pack(-expand=>1);

$main->fileevent(\*$H,'readable',[\&fill,$t]);

MainLoop;

sub fill {
  my ($w) = @_;
  my $text;
  my $text =<$H>;
  $w->delete('0.0','end');
  $w->insert('end',$text);
  $w->yview('end');
}
[download]

That might work...but the fill method never seems to get called?

Oh yeah, you have a windows version that dosn't like tk's fileevent method. Some windows versions can use it, others can't. In that case, instead of a fileevent, you can setup a timer to do the read. You would need the timer to be faster than the log-line-writing speed, so you don't miss a line.

But you are probably better off using the win32 modules that jdtoronto showed you. See Perl/Tk App and Interprocess Communication for a discussion. BrowserUk shows some nice threaded methods that work on win32.

Also use the Search Box and search for "win32 tail" for some other ideas.

---

I'm not really a human, but I play one on earth. Cogito ergo sum a bum

use Win32;
use Win32::ChangeNotify;

my $appdir      = Win32::GetFolderPath(Win32::CSIDL_APPDATA);
my $notify_dir  = $appdir . '/Provider/Application/';
my $notify_file = $notify_dir . 'yourfile.txt';
my $notifyObj;

if ( $notifyObj = Win32::ChangeNotify->new( $notify_dir, 0, "LAST_WRIT
+E" ) ) {
  print "We have a notifyObj object\n";
  $mw->repeat( 2000, \&checkNotify );
}
else {
  print "Application not installed on this machine\n";
}

sub checkNotify {
  my $rv = $notifyObj->wait(0);
  print "Found a change\n" if $rv == 1;
  $notifyObj->reset;
  if ($rv) {
     # DO what you need to do
  }
}
[download]

updated added code sample

I've looked at this module before, and I seem to run into a similar peformance issue.

A couple of simple things if you had performance difficulties. After you have the $notifyObj you will notice that I don't actually use the Notify portion of Win32::ChangeNotify. You need to use the Tk timer event to check the file, you will see from the line:

$mw->repeat( 2000, \&checkNotify );
[download]

That I use the Tk internal timer to call checkNotify, then in that sub I do:

my $rv = $notifyObj->wait(0);
[download]

So I call the notify object with a timeout of 0 - i.e. I ask it to return immediately with the status. Just to check, I have Benchmark already running in the application the code came from. Here are the timings for three runs through the changeNotofy:

A3G took: 8.82149e-005 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 C
+PU)
A3G took: 0.000113964 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 CP
+U)
A3G took: 8.60691e-005 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 C
+PU)
[download]

At a maximum of 114us I don't see a performance issue here.

jdtoronto

Here's a simple threaded tail and a simple Tk app that uses it.

The threaded tail doesn't chase inodes or anything fancy like that. It only displays new lines not a few existing ones (though that could be easily changed).

It uses negligable cpu with the default setting of 100 milliseconds sleep after a failed attempt to read a new line.

#!perl -slw
use strict;
package threads::Tail;
use threads;
use threads::shared;
use Thread::Queue;

our @ISA = 'Thread::Queue';

my $die:shared = 0;

sub tail{
    my( $Q, $filename, $delay ) = @_;
    open my $fh, '<', $filename or die "$filename: $!";
    seek $fh, 0, 2;
    until( $die ) {
        my $line = <$fh>;
        Win32::Sleep( $delay ), next unless defined $line;
        $Q->enqueue( $line );
    }
}

sub new {
    my( $class, $filename, %args ) = @_;
    my $Q = new Thread::Queue;
    threads->new( \&tail, $Q, $filename, $args{ delay } || 100 )->deta
+ch;
    return bless $Q, $class;
}

sub DESTROY {
    $die = 1;
    sleep 1;
    return;
}
1;

package main;
#use threads::Tail;

my $Q = threads::Tail->new( $ARGV[ 0 ], delay => 100 );

require Tk::Text;

my $mw = MainWindow->new( -width => 400, -height => 400 );
my $text = $mw->Text(
    -wrap   => 'none',
    -height => 20,
)->pack( -expand => 1 );

my $repeat;
$repeat = $mw->repeat(
    100 => sub {
        while( $Q->pending ) {
            my $line = $Q->dequeue;
            return unless $line;
            $text->insert( 'end', $line );
            $text->yview( 'end' );
        }
    }
);

$mw->MainLoop;
[download]