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