Thanks for that, Zentara, good information.

It's not clear to me if what you aren't understanding is related to the threading, or just to the operations of the ssh connections (of which I know nuu-thiiing; Nuu-thiiingg:)?

As best as I can tell, your use of threading seems perfectly vanilla and sensible.

BrowserUK: lol neither am I :-)

I guess the main thing I don't understand is why my "tail -f" sessions die when I join those threads. My understanding of join() is that it tells the program to wait for the thread to finish. But a tail -f by itself would never finish, right?

A quick look at the POD suggests that Net::OpenSSH implements timeouts that will close connections after a lack of network activity.

A grep inside turns up this calculation which suggests that the default timeout is 90 (or 30?) seconds:

my $timeout = int((($self->{_timeout} || 90) + 2)/3);
[download]

My guess is that if the remote system is idle, tail -f syslog will produce no output and so the module closes the connection. Maybe you should consider using an explicit timeout.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

The start of some sanity?

Hmm, actually I'm seeing in some cases that it merely detaches those tail -f threads. What would be the best way to actually terminate those tail -f threads when I'm ready? There seem to be a lot of options.

If you are already using 0.57, enable debugging and post here the output:

$Net::OpenSSH::debug = -1;
[download]

Apologies for the delay in responding. I was indeed at version 0.50, and I was about to upgrade when I realized that I was actually dependent on this behavior to get my job done :-) So I finished my work before upgrading.

After upgrading, the join() on the tail process hangs forever, as one might expect.

Problem solved (sorta!). In any case now I can work on elegant ways to kill the threads, and anyways feel like what's going on makes sense.

Thanks!

In any case now I can work on elegant ways to kill the threads ...

There is no "elegant way to kill a thread".

Your best solution, assuming it is possible, would be to enable a timeout on the ssh connection.

Your second best solution would be to use a timer/signal to interrupt the read. That is difficult (if not impossible), due to Perl SAFE SIGNALS.

The third best solution would be to set the socket non-blocking and only read when there is something available. (Ie.Poll!)

The problem with killing the thread -- assuming you discover a reliable mechanism for doing so(*) -- is that all the data you've already so carefully arranged to capture, would be discarded. Ie. As you are returning the captured data as the return value from the thread, you'll never see it if you kill the thread.

(*)The problem here is that to kill the thread, you first need to interrupt the read. And if you can interrupt the read, there is no need to kill the thread.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

The start of some sanity?

In any case now I can work on elegant ways to kill the threads

This is elegant enough for me, but I'm easy. :-)

#!/usr/bin/perl -w
use strict;
use threads;
use threads::shared;

my $timer_go:shared = 0;

my $worker = threads->create(\&worker);
my $timer = threads->create(\&timer,$worker)->detach();

print "hit enter to start\n";
<>;
$timer_go=1;


while( (scalar threads->list) > 0   ){
 print scalar threads->list,"\n"; 
 sleep 1;
foreach my $thread (threads->list) {
   if( $thread->is_joinable ){ $thread->join;}
   }
}

print "worker joined, all done\n";
exit;


sub timer {
  my $worker = shift;
   while(1){     
       if($timer_go){
        my $count = 0;
             while(1){ 
                  $count++;
                  if($count > 5){    
                         print "timed out\n";
                          # Send a signal to a thread
                         $worker->kill('INT');
                         return; # will destroy a detached thread
                        } 
                  sleep 1;
                  print "timing $count\n";
            }
       }else{sleep 1}
    }
}

sub worker {
       $|++;
       $SIG{INT} = sub{ warn "Caught Zap!\n"; threads->exit() };
       # threads->exit() will exit thread only

      while(1){sleep 1;  next}

      return;
}
[download]

---

I'm not really a human, but I play one on earth.
Old Perl Programmer Haiku ................... flash japh