874a4ae1670c96904fc1bf2561207986a20761f1
[OpenSRF.git] / src / perl / lib / OpenSRF / DomainObject / oilsResponse.pm
1 package OpenSRF::DomainObject::oilsResponse;
2 use vars qw/@EXPORT_OK %EXPORT_TAGS/;
3 use Exporter;
4 use OpenSRF::Utils::JSON;
5 use base qw/Exporter/;
6 use OpenSRF::Utils::Logger qw/:level/;
7
8 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfResponse', name => 'OpenSRF::DomainObject::oilsResponse', type => 'hash' );
9
10 BEGIN {
11 @EXPORT_OK = qw/STATUS_CONTINUE STATUS_OK STATUS_ACCEPTED
12                                         STATUS_BADREQUEST STATUS_UNAUTHORIZED STATUS_FORBIDDEN
13                                         STATUS_NOTFOUND STATUS_NOTALLOWED STATUS_TIMEOUT
14                                         STATUS_INTERNALSERVERERROR STATUS_NOTIMPLEMENTED
15                                         STATUS_VERSIONNOTSUPPORTED STATUS_REDIRECTED 
16                                         STATUS_EXPFAILED STATUS_COMPLETE STATUS_PARTIAL
17                                         STATUS_NOCONTENT/;
18
19 %EXPORT_TAGS = (
20         status => [ qw/STATUS_CONTINUE STATUS_OK STATUS_ACCEPTED
21                                         STATUS_BADREQUEST STATUS_UNAUTHORIZED STATUS_FORBIDDEN
22                                         STATUS_NOTFOUND STATUS_NOTALLOWED STATUS_TIMEOUT
23                                         STATUS_INTERNALSERVERERROR STATUS_NOTIMPLEMENTED
24                                         STATUS_VERSIONNOTSUPPORTED STATUS_REDIRECTED 
25                                         STATUS_EXPFAILED STATUS_COMPLETE STATUS_PARTIAL
26                                         STATUS_NOCONTENT/ ],
27 );
28
29 }
30
31 =head1 NAME
32
33 OpenSRF::DomainObject::oilsResponse
34
35 =head1 SYNOPSIS
36
37 use OpenSRF::DomainObject::oilsResponse qw/:status/;
38
39 my $resp = OpenSRF::DomainObject::oilsResponse->new;
40
41 $resp->status( 'a status message' );
42
43 $resp->statusCode( STATUS_CONTINUE );
44
45 $client->respond( $resp );
46
47 =head1 ABSTRACT
48
49 OpenSRF::DomainObject::oilsResponse implements the base class for all Application
50 layer messages send between the client and server.
51
52 =cut
53
54 sub STATUS_CONTINUE             { return 100 }
55
56 sub STATUS_OK                   { return 200 }
57 sub STATUS_ACCEPTED             { return 202 }
58 sub STATUS_COMPLETE             { return 205 }
59
60 sub STATUS_PARTIAL              { return 206 }
61 sub STATUS_NOCONTENT    { return 204 }
62
63 sub STATUS_REDIRECTED   { return 307 }
64
65 sub STATUS_BADREQUEST   { return 400 }
66 sub STATUS_UNAUTHORIZED { return 401 }
67 sub STATUS_FORBIDDEN            { return 403 }
68 sub STATUS_NOTFOUND             { return 404 }
69 sub STATUS_NOTALLOWED   { return 405 }
70 sub STATUS_TIMEOUT              { return 408 }
71 sub STATUS_EXPFAILED            { return 417 }
72
73 sub STATUS_INTERNALSERVERERROR  { return 500 }
74 sub STATUS_NOTIMPLEMENTED                       { return 501 }
75 sub STATUS_VERSIONNOTSUPPORTED  { return 505 }
76
77 my $log = 'OpenSRF::Utils::Logger';
78
79 sub toString {
80         my $self = shift;
81         return OpenSRF::Utils::JSON->perl2JSON($self);
82 }
83
84 sub new {
85         my $class = shift;
86         $class = ref($class) || $class;
87
88         my $default_status = eval "\$${class}::status";
89         my $default_statusCode = eval "\$${class}::statusCode";
90
91         my %args = (    status => $default_status,
92                         statusCode => $default_statusCode,
93                         @_ );
94
95         return bless( \%args => $class );
96 }
97
98 sub status {
99         my $self = shift;
100         my $val = shift;
101         $self->{status} = $val if (defined $val);
102         return $self->{status};
103 }
104
105 sub statusCode {
106         my $self = shift;
107         my $val = shift;
108         $self->{statusCode} = $val if (defined $val);
109         return $self->{statusCode};
110 }
111
112 #-------------------------------------------------------------------------------
113
114 package OpenSRF::DomainObject::oilsStatus;
115 use OpenSRF::DomainObject::oilsResponse qw/:status/;
116 use base 'OpenSRF::DomainObject::oilsResponse';
117 use vars qw/$status $statusCode/;
118 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfStatus', name => 'OpenSRF::DomainObject::oilsStatus', type => 'hash' );
119
120 =head1 NAME
121
122 OpenSRF::DomainObject::oilsException
123
124 =head1 SYNOPSIS
125
126 use OpenSRF::DomainObject::oilsResponse;
127
128 ...
129
130 # something happens.
131
132 $client->status( OpenSRF::DomainObject::oilsStatus->new );
133
134 =head1 ABSTRACT
135
136 The base class for Status messages sent between client and server.  This
137 is implemented on top of the C<OpenSRF::DomainObject::oilsResponse> class, and 
138 sets the default B<status> to C<Status> and B<statusCode> to C<STATUS_OK>.
139
140 =cut
141
142 $status = 'Status';
143 $statusCode = STATUS_OK;
144
145 #-------------------------------------------------------------------------------
146
147 package OpenSRF::DomainObject::oilsConnectStatus;
148 use OpenSRF::DomainObject::oilsResponse qw/:status/;
149 use base 'OpenSRF::DomainObject::oilsStatus';
150 use vars qw/$status $statusCode/;
151 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfConnectStatus', name => 'OpenSRF::DomainObject::oilsConnectStatus', type => 'hash' );
152
153 =head1 NAME
154
155 OpenSRF::DomainObject::oilsConnectStatus
156
157 =head1 SYNOPSIS
158
159 use OpenSRF::DomainObject::oilsResponse;
160
161 ...
162
163 # something happens.
164
165 $client->status( new OpenSRF::DomainObject::oilsConnectStatus );
166
167 =head1 ABSTRACT
168
169 The class for Stati relating to the connection status of a session.  This
170 is implemented on top of the C<OpenSRF::DomainObject::oilsStatus> class, and 
171 sets the default B<status> to C<Connection Successful> and B<statusCode> to C<STATUS_OK>.
172
173 =head1 SEE ALSO
174
175 B<OpenSRF::DomainObject::oilsStatus>
176
177 =cut
178
179 $status = 'Connection Successful';
180 $statusCode = STATUS_OK;
181
182 #-------------------------------------------------------------------------------
183
184 package OpenSRF::DomainObject::oilsContinueStatus;
185 use OpenSRF::DomainObject::oilsResponse qw/:status/;
186 use base 'OpenSRF::DomainObject::oilsStatus';
187 use vars qw/$status $statusCode/;
188 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfContinueStatus', name => 'OpenSRF::DomainObject::oilsContinueStatus', type => 'hash' );
189
190 =head1 NAME
191
192 OpenSRF::DomainObject::oilsContinueStatus
193
194 =head1 SYNOPSIS
195
196 use OpenSRF::DomainObject::oilsResponse;
197
198 ...
199
200 # something happens.
201
202 $client->status( new OpenSRF::DomainObject::oilsContinueStatus );
203
204 =head1 ABSTRACT
205
206 Implements the STATUS_CONTINUE message, informing the client that it should
207 continue to wait for a response to its request.
208
209 =head1 SEE ALSO
210
211 B<OpenSRF::DomainObject::oilsStatus>
212
213 =cut
214
215 $status = 'Please hold.  Creating response...';
216 $statusCode = STATUS_CONTINUE;
217
218 1;
219
220 #-------------------------------------------------------------------------------
221
222 package OpenSRF::DomainObject::oilsResult;
223 use OpenSRF::DomainObject::oilsResponse qw/:status/;
224 use base 'OpenSRF::DomainObject::oilsResponse';
225 use vars qw/$status $statusCode/;
226 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfResult', name => 'OpenSRF::DomainObject::oilsResult', type => 'hash' );
227
228
229 $status = 'OK';
230 $statusCode = STATUS_OK;
231
232 =head1 NAME
233
234 OpenSRF::DomainObject::oilsResult
235
236 =head1 SYNOPSIS
237
238 use OpenSRF::DomainObject::oilsResponse;
239
240  .... do stuff, create $object ...
241
242 my $res = OpenSRF::DomainObject::oilsResult->new;
243
244 $res->content($object)
245
246 $session->respond( $res );
247
248 =head1 ABSTRACT
249
250 This is the base class for encapuslating RESULT messages send from the server
251 to a client.  It is a subclass of B<OpenSRF::DomainObject::oilsResponse>, and
252 sets B<status> to C<OK> and B<statusCode> to C<STATUS_OK>.
253
254 =head1 METHODS
255
256 =head2 OpenSRF::DomainObject::oilsMessage->content( [$new_content] )
257
258 =over 4
259
260 Sets or gets the content of the response.  This should be exactly one object
261 of (sub)type domainObject or domainObjectCollection.
262
263 =back
264
265 =cut
266
267 sub content {
268         my $self = shift;
269         my $val = shift;
270
271         $self->{content} = $val if (defined $val);
272         return $self->{content};
273 }
274
275 =head1 SEE ALSO
276
277 B<OpenSRF::DomainObject::oilsResponse>
278
279 =cut
280
281 1;
282
283 #-------------------------------------------------------------------------------
284
285 package OpenSRF::DomainObject::oilsResult::Partial;
286 use OpenSRF::DomainObject::oilsResponse qw/:status/;
287 use base 'OpenSRF::DomainObject::oilsResult';
288 use vars qw/$status $statusCode/;
289 OpenSRF::Utils::JSON->register_class_hint(
290     hint => 'osrfResultPartial',
291     name => 'OpenSRF::DomainObject::oilsResult::Partial',
292     type => 'hash');
293
294
295 $status = 'Partial Response';
296 $statusCode = STATUS_PARTIAL;
297
298 =head1 NAME
299
300 OpenSRF::DomainObject::oilsResult::Partial
301
302 =head1 SYNOPSIS
303
304 This class is used internally to break apart large OpenSRF messages into small
305 chunks, to reduce the maximum possible stanza size when sending a message over
306 XMPP.
307
308 =cut
309
310 sub content {
311         my $self = shift;
312         my $val = shift;
313
314         $self->{content} = $val if (defined $val);
315         return $self->{content};
316 }
317
318 =head1 SEE ALSO
319
320 B<OpenSRF::DomainObject::oilsResponse>
321
322 =cut
323
324 1;
325
326 #-------------------------------------------------------------------------------
327
328 package OpenSRF::DomainObject::oilsResult::PartialComplete;
329 use OpenSRF::DomainObject::oilsResponse qw/:status/;
330 use base 'OpenSRF::DomainObject::oilsResult';
331 use vars qw/$status $statusCode/;
332 OpenSRF::Utils::JSON->register_class_hint( 
333     hint => 'osrfResultPartialComplete',
334     name => 'OpenSRF::DomainObject::oilsResult::PartialComplete',
335     type => 'hash');
336
337
338 $status = 'Partial Response Finalized';
339 $statusCode = STATUS_NOCONTENT;
340
341 =head1 NAME
342
343 OpenSRF::DomainObject::oilsResult::PartialComplete
344
345 =head1 SYNOPSIS
346
347 This class is used internally to mark the end of a stream of small partial
348 OpenSRF messages of type OpenSRF::DomainObject::oilsResult::Partial.
349
350 =cut
351
352 sub content {
353         my $self = shift;
354         my $val = shift;
355
356         $self->{content} = $val if (defined $val);
357         return $self->{content};
358 }
359
360 =head1 SEE ALSO
361
362 B<OpenSRF::DomainObject::oilsResponse>
363
364 =cut
365
366 1;
367
368 #-------------------------------------------------------------------------------
369
370 package OpenSRF::DomainObject::oilsException;
371 use OpenSRF::DomainObject::oilsResponse qw/:status/;
372 use OpenSRF::EX;
373 use base qw/OpenSRF::EX OpenSRF::DomainObject::oilsResponse/;
374 use vars qw/$status $statusCode/;
375 use Error;
376 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfException', name => 'OpenSRF::DomainObject::oilsException', type => 'hash' );
377
378 sub message {
379         my $self = shift;
380         return '<' . $self->statusCode . '>  ' . $self->status;
381 }
382
383 sub new {
384         my $class = shift;
385         return $class->OpenSRF::DomainObject::oilsResponse::new( @_ );
386 }
387
388
389 =head1 NAME
390
391 OpenSRF::DomainObject::oilsException
392
393 =head1 SYNOPSIS
394
395 use OpenSRF::DomainObject::oilsResponse;
396
397 ...
398
399 # something breaks.
400
401 $client->send( 'ERROR', OpenSRF::DomainObject::oilsException->new( status => "ARRRRRRG!" ) );
402
403 =head1 ABSTRACT
404
405 The base class for Exception messages sent between client and server.  This
406 is implemented on top of the C<OpenSRF::DomainObject::oilsResponse> class, and 
407 sets the default B<status> to C<Exception occurred> and B<statusCode> to C<STATUS_BADREQUEST>.
408
409 =cut
410
411 $status = 'Exception occurred';
412 $statusCode = STATUS_INTERNALSERVERERROR;
413
414 #-------------------------------------------------------------------------------
415
416 package OpenSRF::DomainObject::oilsConnectException;
417 use OpenSRF::DomainObject::oilsResponse qw/:status/;
418 use OpenSRF::EX;
419 use base qw/OpenSRF::DomainObject::oilsException OpenSRF::EX::ERROR/;
420 use vars qw/$status $statusCode/;
421 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfConnectException', name => 'OpenSRF::DomainObject::oilsConnectException', type => 'hash' );
422
423 =head1 NAME
424
425 OpenSRF::DomainObject::oilsConnectException
426
427 =head1 SYNOPSIS
428
429 use OpenSRF::DomainObject::oilsResponse;
430
431 ...
432
433 # something breaks while connecting.
434
435 $client->send( 'ERROR', new OpenSRF::DomainObject::oilsConnectException );
436
437 =head1 ABSTRACT
438
439 The class for Exceptions that occur durring the B<CONNECT> phase of a session.  This
440 is implemented on top of the C<OpenSRF::DomainObject::oilsException> class, and 
441 sets the default B<status> to C<Connect Request Failed> and B<statusCode> to C<STATUS_FORBIDDEN>.
442
443 =head1 SEE ALSO
444
445 B<OpenSRF::DomainObject::oilsException>
446
447 =cut
448
449
450 $status = 'Connect Request Failed';
451 $statusCode = STATUS_FORBIDDEN;
452
453 #-------------------------------------------------------------------------------
454
455 package OpenSRF::DomainObject::oilsMethodException;
456 use OpenSRF::DomainObject::oilsResponse qw/:status/;
457 use base 'OpenSRF::DomainObject::oilsException';
458 use vars qw/$status $statusCode/;
459 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfMethodException', name => 'OpenSRF::DomainObject::oilsMethodException', type => 'hash' );
460
461 =head1 NAME
462
463 OpenSRF::DomainObject::oilsMethodException
464
465 =head1 SYNOPSIS
466
467 use OpenSRF::DomainObject::oilsResponse;
468
469 ...
470
471 # something breaks while looking up or starting
472 # a method call.
473
474 $client->send( 'ERROR', new OpenSRF::DomainObject::oilsMethodException );
475
476 =head1 ABSTRACT
477
478 The class for Exceptions that occur during the B<CONNECT> phase of a session.  This
479 is implemented on top of the C<OpenSRF::DomainObject::oilsException> class, and 
480 sets the default B<status> to C<Connect Request Failed> and B<statusCode> to C<STATUS_NOTFOUND>.
481
482 =head1 SEE ALSO
483
484 B<OpenSRF::DomainObject::oilsException>
485
486 =cut
487
488
489 $status = 'A server error occurred during method execution';
490 $statusCode = STATUS_INTERNALSERVERERROR;
491
492 # -------------------------------------------
493
494 package OpenSRF::DomainObject::oilsServerError;
495 use OpenSRF::DomainObject::oilsResponse qw/:status/;
496 use base 'OpenSRF::DomainObject::oilsException';
497 use vars qw/$status $statusCode/;
498 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfServerError', name => 'OpenSRF::DomainObject::oilsServerError', type => 'hash' );
499
500 $status = 'Internal Server Error';
501 $statusCode = STATUS_INTERNALSERVERERROR;
502
503 # -------------------------------------------
504
505 package OpenSRF::DomainObject::oilsBrokenSession;
506 use OpenSRF::DomainObject::oilsResponse qw/:status/;
507 use OpenSRF::EX;
508 use base qw/OpenSRF::DomainObject::oilsException OpenSRF::EX::ERROR/;
509 use vars qw/$status $statusCode/;
510 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfBrokenSession', name => 'OpenSRF::DomainObject::oilsBrokenSession', type => 'hash' );
511 $status = "Request on Disconnected Session";
512 $statusCode = STATUS_EXPFAILED;
513
514 #-------------------------------------------------------------------------------
515
516 package OpenSRF::DomainObject::oilsXMLParseError;
517 use OpenSRF::DomainObject::oilsResponse qw/:status/;
518 use OpenSRF::EX;
519 use base qw/OpenSRF::DomainObject::oilsException OpenSRF::EX::ERROR/;
520 use vars qw/$status $statusCode/;
521 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfXMLParseError', name => 'OpenSRF::DomainObject::oilsXMLParseError', type => 'hash' );
522 $status = "XML Parse Error";
523 $statusCode = STATUS_EXPFAILED;
524
525 #-------------------------------------------------------------------------------
526
527 package OpenSRF::DomainObject::oilsAuthException;
528 use OpenSRF::DomainObject::oilsResponse qw/:status/;
529 use OpenSRF::EX;
530 use base qw/OpenSRF::DomainObject::oilsException OpenSRF::EX::ERROR/;
531 OpenSRF::Utils::JSON->register_class_hint( hint => 'osrfAuthException', name => 'OpenSRF::DomainObject::oilsAuthException', type => 'hash' );
532 use vars qw/$status $statusCode/;
533 $status = "Authentication Failure";
534 $statusCode = STATUS_FORBIDDEN;
535
536 1;