src/perlmods/OpenSRF/Transport.pm

   1 package OpenSRF::Transport;
   2 use strict; use warnings;
   3 use base 'OpenSRF';
   4 use OpenSRF::DOM;
   5 use OpenSRF::AppSession;
   6 use OpenSRF::Utils::Logger qw(:level);
   7 use OpenSRF::DomainObject::oilsResponse qw/:status/;
   8 use OpenSRF::EX qw/:try/;
   9 use OpenSRF::Transport::SlimJabber::MessageWrapper;
  10
  11 #------------------
  12 # --- These must be implemented by all Transport subclasses
  13 # -------------------------------------------
  14
  15 =head2 get_listener
  16
  17 Returns the package name of the package the system will use to
  18 gather incoming requests
  19
  20 =cut
  21
  22 sub get_listener { shift()->alert_abstract(); }
  23
  24 =head2 get_peer_client
  25
  26 Returns the name of the package responsible for client communication
  27
  28 =cut
  29
  30 sub get_peer_client { shift()->alert_abstract(); }
  31
  32 =head2 get_msg_envelope
  33
  34 Returns the name of the package responsible for parsing incoming messages
  35
  36 =cut
  37
  38 sub get_msg_envelope { shift()->alert_abstract(); }
  39
  40 # -------------------------------------------
  41
  42 our $message_envelope;
  43 my $logger = "OpenSRF::Utils::Logger";
  44
  45
  46
  47 =head2 message_envelope( [$envelope] );
  48
  49 Sets the message envelope class that will allow us to extract
  50 information from the messages we receive from the low
  51 level transport
  52
  53 =cut
  54
  55 sub message_envelope {
  56         my( $class, $envelope ) = @_;
  57         if( $envelope ) {
  58                 $message_envelope = $envelope;
  59                 eval "use $envelope;";
  60                 if( $@ ) {
  61                         $logger->error(
  62                                         "Error loading message_envelope: $envelope -> $@", ERROR);
  63                 }
  64         }
  65         return $message_envelope;
  66 }
  67
  68 =head2 handler( $data )
  69
  70 Creates a new MessageWrapper, extracts the remote_id, session_id, and message body
  71 from the message.  Then, creates or retrieves the AppSession object with the session_id and remote_id.
  72 Finally, creates the message document from the body of the message and calls
  73 the handler method on the message document.
  74
  75 =cut
  76
  77 sub handler {
  78         my( $class, $service, $data ) = @_;
  79
  80         $logger->transport( "Transport handler() received $data", INTERNAL );
  81
  82         # pass data to the message envelope
  83         my $helper = OpenSRF::Transport::SlimJabber::MessageWrapper->new( $data );
  84
  85         # Extract message information
  86         my $remote_id   = $helper->get_remote_id();
  87         my $sess_id     = $helper->get_sess_id();
  88         my $body        = $helper->get_body();
  89         my $type        = $helper->get_msg_type();
  90
  91         $logger->transport(
  92                         "Transport building/retrieving session: $service, $remote_id, $sess_id", DEBUG );
  93
  94         # See if the app_session already exists.  If so, make
  95         # sure the sender hasn't changed if we're a server
  96         my $app_session = OpenSRF::AppSession->find( $sess_id );
  97         if( $app_session and $app_session->endpoint == $app_session->SERVER() and
  98                         $app_session->remote_id ne $remote_id ) {
  99                 $logger->transport( "Backend Gone or invalid sender", INTERNAL );
 100                 my $res = OpenSRF::DomainObject::oilsBrokenSession->new();
 101                 $res->status( "Backend Gone or invalid sender, Reconnect" );
 102                 $app_session->status( $res );
 103                 return 1;
 104         }
 105
 106         # Retrieve or build the app_session as appropriate (server_build decides which to do)
 107         $logger->transport( "AppSession is valid or does not exist yet", INTERNAL );
 108         $app_session = OpenSRF::AppSession->server_build( $sess_id, $remote_id, $service );
 109
 110         if( ! $app_session ) {
 111                 throw OpenSRF::EX::Session ("Transport::handler(): No AppSession object returned from server_build()");
 112         }
 113
 114         # Create a document from the XML contained within the message
 115         my $doc;
 116         eval { $doc = OpenSRF::DOM->new->parse_string($body); };
 117         if( $@ ) {
 118
 119                 $logger->transport( "Received bogus XML", INFO );
 120                 $logger->transport( "Bogus XML data: \n $body \n", INTERNAL );
 121                 my $res = OpenSRF::DomainObject::oilsXMLParseError->new( status => "XML Parse Error --- $body" );
 122
 123                 $app_session->status($res);
 124                 #$app_session->kill_me;
 125                 return 1;
 126         }
 127
 128         $logger->transport( "Transport::handler() creating \n$body", INTERNAL );
 129
 130         # We need to disconnect the session if we got a jabber error on the client side.  For
 131         # server side, we'll just tear down the session and go away.
 132         if (defined($type) and $type eq 'error') {
 133                 # If we're a server
 134                 if( $app_session->endpoint == $app_session->SERVER() ) {
 135                         $app_session->kill_me;
 136                         return 1;
 137                 } else {
 138                         $app_session->reset;
 139                         $app_session->state( $app_session->DISCONNECTED );
 140                         $app_session->push_resend( $app_session->app_request( $doc->documentElement->firstChild->threadTrace ) );
 141                         return 1;
 142                 }
 143         }
 144
 145         # cycle through and pass each oilsMessage contained in the message
 146         # up to the message layer for processing.
 147         for my $msg ($doc->documentElement->childNodes) {
 148
 149                 $logger->transport(
 150                                 "Transport::handler()passing to message handler \n".$msg->toString(1), DEBUG );
 151
 152                 $logger->transport(
 153                                 "Transport passing up ".$msg->type." from ".
 154                                 $app_session->remote_id . " with threadTrace [" . $msg->threadTrace."]", INFO );
 155
 156                 next unless (   $msg->nodeName eq 'oils:domainObject' &&
 157                                 $msg->getAttribute('name') eq 'oilsMessage' );
 158
 159                 if( $app_session->endpoint == $app_session->SERVER() ) {
 160
 161                         try {
 162
 163                                 if( ! $msg->handler( $app_session ) ) { return 0; }
 164
 165                         } catch Error with {
 166
 167                                 my $e = shift;
 168                                 my $res = OpenSRF::DomainObject::oilsServerError->new();
 169                                 $res->status( $res->status . "\n" . $e->text );
 170                                 $logger->error($res->stringify);
 171                                 $app_session->status($res) if $res;
 172                                 $app_session->kill_me;
 173                                 return 0;
 174
 175                         };
 176
 177                 } else {
 178
 179                         if( ! $msg->handler( $app_session ) ) { return 0; }
 180
 181                 }
 182
 183         }
 184
 185
 186         return $app_session;
 187 }
 188
 189 1;