OpenSRF/src/perlmods/OpenSRF/Transport/SlimJabber/Inbound.pm

   1 package OpenSRF::Transport::SlimJabber::Inbound;
   2 use strict;use warnings;
   3 use base qw/OpenSRF::Transport::SlimJabber::Client/;
   4 use OpenSRF::EX qw(:try);
   5 use OpenSRF::Utils::Logger qw(:level);
   6 use OpenSRF::Utils::SettingsClient;
   7 use OpenSRF::Utils::Config;
   8 use Time::HiRes qw/usleep/;
   9
  10 my $logger = "OpenSRF::Utils::Logger";
  11
  12 =head1 Description
  13
  14 This is the jabber connection where all incoming client requests will be accepted.
  15 This connection takes the data, passes it off to the system then returns to take
  16 more data.  Connection params are all taken from the config file and the values
  17 retreived are based on the $app name passed into new().
  18
  19 This service should be loaded at system startup.
  20
  21 =cut
  22
  23 # XXX This will be overhauled to connect as a component instead of as
  24 # a user.  all in good time, though.
  25
  26 {
  27         my $unix_sock;
  28         sub unix_sock { return $unix_sock; }
  29         my $instance;
  30
  31         sub new {
  32                 my( $class, $app ) = @_;
  33                 $class = ref( $class ) || $class;
  34                 if( ! $instance ) {
  35
  36                         my $conf = OpenSRF::Utils::Config->current;
  37                         my $domains = $conf->bootstrap->domains;
  38
  39                         my $username    = $conf->bootstrap->username;
  40                         my $password    = $conf->bootstrap->passwd;
  41                         my $port                        = $conf->bootstrap->port;
  42                         my $host                        = $domains->[0]; # XXX for now...
  43                         my $resource    = $app . '_listener_at_' . $conf->env->hostname;
  44
  45                         my $router_name = $conf->bootstrap->router_name;
  46                         # no router, only one listener running..
  47                         if(!$router_name) {
  48                                 $username = "router";
  49                                 $resource = $app;
  50                         }
  51
  52                         OpenSRF::Utils::Logger->transport("Inbound as $username, $password, $resource, $host, $port\n", INTERNAL );
  53
  54                         my $self = __PACKAGE__->SUPER::new(
  55                                         username                => $username,
  56                                         resource                => $resource,
  57                                         password                => $password,
  58                                         host                    => $host,
  59                                         port                    => $port,
  60                                         );
  61
  62                         $self->{app} = $app;
  63
  64                         my $client = OpenSRF::Utils::SettingsClient->new();
  65                         my $f = $client->config_value("dirs", "sock");
  66                         $unix_sock = join( "/", $f,
  67                                         $client->config_value("apps", $app, "unix_config", "unix_sock" ));
  68                         bless( $self, $class );
  69                         $instance = $self;
  70                 }
  71                 return $instance;
  72         }
  73
  74 }
  75
  76 sub DESTROY {
  77         my $self = shift;
  78
  79         my $routers = $self->{routers}; #store for destroy
  80         my $router_name = $self->{router_name};
  81
  82         unless($router_name and $routers) {
  83                 return;
  84         }
  85
  86         my @targets;
  87         for my $router (@$routers) {
  88                 push @targets, "$router_name\@$router/router";
  89         }
  90
  91         for my $router (@targets) {
  92                 if($self->tcp_connected()) {
  93                         $self->send( to => $router, body => "registering",
  94                                 router_command => "unregister" , router_class => $self->{app} );
  95                 }
  96         }
  97 }
  98
  99 sub listen {
 100         my $self = shift;
 101
 102         my $routers;
 103
 104         try {
 105
 106                 my $conf = OpenSRF::Utils::Config->current;
 107                 my $router_name = $conf->bootstrap->router_name;
 108                 my $routers = $conf->bootstrap->domains;
 109
 110                 $self->{routers} = $routers; #store for destroy
 111                 $self->{router_name} = $router_name;
 112
 113                 if($router_name and $routers) {
 114
 115                         my @targets;
 116                         for my $router (@$routers) {
 117                                 push @targets, "$router_name\@$router/router";
 118                         }
 119
 120                         for my $router (@targets) {
 121                                 $logger->transport( $self->{app} . " connecting to router $router", INFO );
 122                                 $self->send( to => $router,
 123                                                 body => "registering", router_command => "register" , router_class => $self->{app} );
 124                         }
 125                         $logger->transport( $self->{app} . " :routers connected", INFO );
 126
 127                 } else {
 128
 129                         $logger->transport("Bypassing routers...", INFO);
 130                 }
 131
 132
 133         } catch OpenSRF::EX::Config with {
 134                 $logger->transport( $self->{app} . ": No routers defined" , WARN );
 135                 # no routers defined
 136         };
 137
 138
 139
 140
 141         $logger->transport( $self->{app} . " going into listen loop", INFO );
 142
 143         while(1) {
 144
 145                 my $sock = $self->unix_sock();
 146                 my $o;
 147
 148                 $logger->debug("Inbound listener calling process()");
 149
 150                 try {
 151                         $o = $self->process( -1 );
 152
 153                         $logger->debug("Inbound listener received ".length($o)." bytes of data");
 154
 155                         if(!$o){
 156                                 $logger->error(
 157                                         "Inbound received no data from the Jabber socket in process()");
 158                                 usleep(100000); # otherwise we loop and pound syslog logger with errors
 159                         }
 160
 161                 } catch OpenSRF::EX::JabberDisconnected with {
 162
 163                         $logger->error("Inbound process lost its ".
 164                                 "jabber connection.  Attempting to reconnect...");
 165                         $self->initialize;
 166                         $o = undef;
 167                 };
 168
 169
 170                 if($o) {
 171                         my $socket = IO::Socket::UNIX->new( Peer => $sock  );
 172                         throw OpenSRF::EX::Socket(
 173                                 "Unable to connect to UnixServer: socket-file: $sock \n :=> $! " )
 174                                 unless ($socket->connected);
 175                         print $socket $o;
 176                         $socket->close;
 177                 }
 178         }
 179
 180         throw OpenSRF::EX::Socket( "How did we get here?!?!" );
 181 }
 182
 183 1;
 184