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) { $resource = $app; }
  47
  48                         OpenSRF::Utils::Logger->transport("Inbound as $username, $password, $resource, $host, $port\n", INTERNAL );
  49
  50                         my $self = __PACKAGE__->SUPER::new(
  51                                         username                => $username,
  52                                         resource                => $resource,
  53                                         password                => $password,
  54                                         host                    => $host,
  55                                         port                    => $port,
  56                                         );
  57
  58                         $self->{app} = $app;
  59
  60                         my $client = OpenSRF::Utils::SettingsClient->new();
  61                         my $f = $client->config_value("dirs", "sock");
  62                         $unix_sock = join( "/", $f,
  63                                         $client->config_value("apps", $app, "unix_config", "unix_sock" ));
  64                         bless( $self, $class );
  65                         $instance = $self;
  66                 }
  67                 return $instance;
  68         }
  69
  70 }
  71
  72 sub DESTROY {
  73         my $self = shift;
  74
  75         my $routers = $self->{routers}; #store for destroy
  76         my $router_name = $self->{router_name};
  77
  78         unless($router_name and $routers) {
  79                 return;
  80         }
  81
  82         my @targets;
  83         for my $router (@$routers) {
  84                 push @targets, "$router_name\@$router/router";
  85         }
  86
  87         for my $router (@targets) {
  88                 if($self->tcp_connected()) {
  89                         $self->send( to => $router, body => "registering",
  90                                 router_command => "unregister" , router_class => $self->{app} );
  91                 }
  92         }
  93 }
  94
  95 sub listen {
  96         my $self = shift;
  97
  98         my $routers;
  99
 100         try {
 101
 102                 my $conf = OpenSRF::Utils::Config->current;
 103                 my $router_name = $conf->bootstrap->router_name;
 104                 my $routers = $conf->bootstrap->domains;
 105
 106                 $self->{routers} = $routers; #store for destroy
 107                 $self->{router_name} = $router_name;
 108
 109                 if($router_name and $routers) {
 110
 111                         my @targets;
 112                         for my $router (@$routers) {
 113                                 push @targets, "$router_name\@$router/router";
 114                         }
 115
 116                         for my $router (@targets) {
 117                                 $logger->transport( $self->{app} . " connecting to router $router", INFO );
 118                                 $self->send( to => $router,
 119                                                 body => "registering", router_command => "register" , router_class => $self->{app} );
 120                         }
 121                         $logger->transport( $self->{app} . " :routers connected", INFO );
 122
 123                 } else {
 124
 125                         $logger->transport("Bypassing routers...", INFO);
 126                 }
 127
 128
 129         } catch OpenSRF::EX::Config with {
 130                 $logger->transport( $self->{app} . ": No routers defined" , WARN );
 131                 # no routers defined
 132         };
 133
 134
 135
 136
 137         $logger->transport( $self->{app} . " going into listen loop", INFO );
 138         while(1) {
 139
 140                 my $sock = $self->unix_sock();
 141                 my $o = $self->process( -1 );
 142
 143                 if( ! defined( $o ) ) {
 144                         throw OpenSRF::EX::Jabber( "Listen Loop failed at 'process()'" );
 145                 }
 146
 147                 my $socket = IO::Socket::UNIX->new( Peer => $sock  );
 148                 throw OpenSRF::EX::Socket( "Unable to connect to UnixServer: socket-file: $sock \n :=> $! " )
 149                         unless ($socket->connected);
 150                 print $socket $o;
 151                 $socket->close;
 152
 153         }
 154
 155         throw OpenSRF::EX::Socket( "How did we get here?!?!" );
 156 }
 157
 158 1;
 159