Changeset a957e92 for perl

Timestamp:

Oct 18, 2009, 3:59:29 PM (15 years ago)

Author:

Alex Vandiver <alexmv@mit.edu>

Branches:

master, release-1.10, release-1.5, release-1.6, release-1.7, release-1.8, release-1.9

Children:

f3678c3

Parents:

99cc3dc

git-author:

Alex Vandiver <alexmv@mit.edu> (03/22/09 02:06:46)

git-committer:

Alex Vandiver <alexmv@mit.edu> (10/18/09 15:59:29)

Message:

Make Jabber try to reconnect when disconnected, at exponential intervals

Make the ConnectionManager store auth information on connect, and use
that auth information to try to reconnect and re-auth.  Use some
simple exponential backoff, capped at 5 minutes, as intervals for
reconnecting.

Location:

perl/modules/Jabber/lib/BarnOwl/Module

Files:

• Jabber.pm (modified) (5 diffs)
• Jabber/Connection.pm (modified) (1 diff)
• Jabber/ConnectionManager.pm (modified) (4 diffs)

perl/modules/Jabber/lib/BarnOwl/Module/Jabber.pm

@@ -132 +132 @@
 
     foreach my $jid ( $conn->getJIDs() ) {
+
+        next unless $conn->jidActive($jid) or $conn->tryReconnect($jid);
+
         my $client = $conn->getConnectionFromJID($jid);
-
         unless($client) {
             $conn->removeConnection($jid);
@@ -140 +142 @@
         my $status = $client->Process(0); # keep-alive
         if ( !defined($status) ) {
-            BarnOwl::error("Jabber account $jid disconnected!");
-            do_logout($jid);
-            next;
+            $conn->scheduleReconnect($jid);
         }
         if ($::shutdown) {
@@ -383 +383 @@
     }
 
-    if ( $conn->jidExists($jidStr) ) {
+    if ( $conn->jidActive($jidStr) ) {
         BarnOwl::error("Already logged in as $jidStr.");
         return;
+    } elsif ($conn->jidExists($jidStr)) {
+        return $conn->tryReconnect($jidStr, 1);
     }
 
@@ -453 +455 @@
                 BarnOwl::error( "Error in connect: " . join( " ", @result ) );
             } else {
+                $conn->setAuth(
+                    $jidStr,
+                    {   %{ $vars{jlogin_authhash} },
+                        password => $vars{jlogin_password}
+                    }
+                );
                 my $roster = $conn->getRosterFromJID($jidStr);
                 $roster->fetch();
@@ -463 +471 @@
                 $client->{fileno} = $client->getSocket()->fileno();
                 #queue_admin_msg("Connected to jabber as $fullJid ($client->{fileno})");
-                BarnOwl::add_dispatch($client->{fileno}, sub { $client->OwlProcess() });
+                BarnOwl::add_dispatch($client->{fileno}, sub { $client->OwlProcess($fullJid) });
 
                 # populate completion from roster.

perl/modules/Jabber/lib/BarnOwl/Module/Jabber/Connection.pm

@@ -142 +142 @@
 sub OwlProcess {
     my $self = shift;
+    my $jid = shift || $self->{SESSION}->{FULLJID};
     my $status = $self->Process(0);
     if ( !defined($status) ) {
-        my $jid = $self->{SESSION}->{FULLJID};
-        BarnOwl::error("Jabber account $jid disconnected!");
-        BarnOwl::Module::Jabber::do_logout($jid);
+        $BarnOwl::Module::Jabber::conn->scheduleReconnect($jid);
     }
+}
+
+=head2 Disconnect
+
+Work around a bug in Net::Jabber::Client where Process' return status
+is not cleared on disconnect.
+
+=cut
+
+sub Disconnect {
+    my $self = shift;
+    delete $self->{PROCESSERROR};
+    return $self->SUPER::Disconnect(@_);
 }
 

perl/modules/Jabber/lib/BarnOwl/Module/Jabber/ConnectionManager.pm

@@ -41 +41 @@
       if $self->{$jidStr}->{Client};
     delete $self->{$jidStr};
+
+    return 1;
+}
+
+sub scheduleReconnect {
+    my $self = shift;
+    my $jidStr = shift;
+    return 0 unless exists $self->{$jidStr};
+    BarnOwl::admin_message(Jabber => "Disconnected from jabber account $jidStr");
+
+    BarnOwl::remove_dispatch($self->{$jidStr}->{Client}->{fileno}) if $self->{$jidStr}->{Client}->{fileno};
+    $self->{$jidStr}->{Client}->Disconnect()
+      if $self->{$jidStr}->{Client};
+
+    $self->{$jidStr}->{Status} = "reconnecting";
+    $self->{$jidStr}->{ReconnectBackoff} = 5;
+    $self->{$jidStr}->{ReconnectAt} = time + $self->{$jidStr}->{ReconnectBackoff};
+    return 1;
+}
+
+sub setAuth {
+    my $self = shift;
+    my $jidStr = shift;
+    $self->{$jidStr}->{Auth} = shift;
+}
+
+sub tryReconnect {
+    my $self = shift;
+    my $jidStr = shift;
+    my $force = shift;
+
+    return 0 unless exists $self->{$jidStr};
+    return 0 unless $self->{$jidStr}{Status} eq "reconnecting";
+    return 0 unless $force or (time > $self->{$jidStr}{ReconnectAt});
+
+    $self->{$jidStr}->{ReconnectBackoff} *= 2;
+    $self->{$jidStr}->{ReconnectBackoff} = 60*5
+        if $self->{$jidStr}->{ReconnectBackoff} > 60*5;
+    $self->{$jidStr}->{ReconnectAt} = time + $self->{$jidStr}->{ReconnectBackoff};
+
+    my $status = $self->{$jidStr}->{Client}->Connect;
+    return 0 unless $status;
+
+    my @result = $self->{$jidStr}->{Client}->AuthSend( %{ $self->{$jidStr}->{Auth} } );
+    if ( !@result || $result[0] ne 'ok' ) {
+        $self->removeConnection($jidStr);
+        BarnOwl::error( "Error in jabber reconnect: " . join( " ", @result ) );
+        return 0;
+    }
+
+    BarnOwl::admin_message(Jabber => "Reconnected to jabber as $jidStr");
+    $self->{$jidStr}{Status} = "available";
 
     return 1;
@@ -88 +140 @@
 }
 
+sub jidActive {
+    my $self = shift;
+    my $jidStr = shift;
+    return(exists $self->{$jidStr} and $self->{$jidStr}{Status} eq "available");
+}
+
 sub sidExists {
     my $self = shift;
@@ -110 +168 @@
     my $jid = shift;
     $jid = $jid->GetJID('full') if UNIVERSAL::isa($jid, 'Net::XMPP::JID');
-    return $self->{$jid}->{Client} if exists $self->{$jid};
+    return $self->{$jid}->{Client} if $self->jidActive($jid);
 }
 
@@ -127 +185 @@
     my $jid = shift;
     $jid = $jid->GetJID('full') if UNIVERSAL::isa($jid, 'Net::XMPP::JID');
-    return $self->{$jid}->{Roster} if exists $self->{$jid};
+    return $self->{$jid}->{Roster} if $self->jidExists($jid);
 }