Initial revision
[OpenSRF.git] / 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::Config;
7 use OpenSRF::Utils::Logger qw(:level);
8 use OpenSRF::DomainObject::oilsResponse qw/:status/;
9 use OpenSRF::EX qw/:try/;
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 = $class->message_envelope->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;