1. Changed osrfLogFacilityToInt() so that it accepts
[OpenSRF.git] / src / libopensrf / osrf_application.c
1 #include <opensrf/osrf_application.h>
2
3 static osrfMethod* _osrfAppBuildMethod( const char* methodName, const char* symbolName,
4                 const char* notes, int argc, int options, void* );
5 static void osrfAppSetOnExit(osrfApplication* app, const char* appName);
6 static int _osrfAppRegisterSysMethods( const char* app );
7 static osrfApplication* _osrfAppFindApplication( const char* name );
8 static osrfMethod* osrfAppFindMethod( osrfApplication* app, const char* methodName );
9 static int _osrfAppRespond( osrfMethodContext* context, const jsonObject* data, int complete );
10 static int _osrfAppPostProcess( osrfMethodContext* context, int retcode );
11 static int _osrfAppRunSystemMethod(osrfMethodContext* context);
12 static int osrfAppIntrospect( osrfMethodContext* ctx );
13 static int osrfAppIntrospectAll( osrfMethodContext* ctx );
14 static int osrfAppEcho( osrfMethodContext* ctx );
15
16 static osrfHash* _osrfAppHash = NULL;
17
18 int osrfAppRegisterApplication( const char* appName, const char* soFile ) {
19         if(!appName || ! soFile) return -1;
20         char* error;
21
22         if(!_osrfAppHash) _osrfAppHash = osrfNewHash();
23
24         osrfLogInfo( OSRF_LOG_MARK, "Registering application %s with file %s", appName, soFile );
25
26         osrfApplication* app = safe_malloc(sizeof(osrfApplication));
27         app->handle = dlopen (soFile, RTLD_NOW);
28         app->onExit = NULL;
29
30         if(!app->handle) {
31                 osrfLogWarning( OSRF_LOG_MARK, "Failed to dlopen library file %s: %s", soFile, dlerror() );
32                 dlerror(); /* clear the error */
33                 free(app);
34                 return -1;
35         }
36
37         app->methods = osrfNewHash();
38         osrfHashSet( _osrfAppHash, app, appName );
39
40         /* see if we can run the initialize method */
41         int (*init) (void);
42         *(void **) (&init) = dlsym(app->handle, "osrfAppInitialize");
43
44         if( (error = dlerror()) != NULL ) {
45                 osrfLogWarning( OSRF_LOG_MARK, 
46                         "! Unable to locate method symbol [osrfAppInitialize] for app %s: %s", appName, error );
47
48         } else {
49
50                 /* run the method */
51                 int ret;
52                 if( (ret = (*init)()) ) {
53                         osrfLogWarning( OSRF_LOG_MARK, "Application %s returned non-zero value from "
54                                         "'osrfAppInitialize', not registering...", appName );
55                         //free(app->name); /* need a method to remove an application from the list */
56                         //free(app);
57                         return ret;
58                 }
59         }
60
61         _osrfAppRegisterSysMethods(appName);
62
63         osrfLogInfo( OSRF_LOG_MARK, "Application %s registered successfully", appName );
64
65         osrfLogSetAppname(appName);
66
67         osrfAppSetOnExit(app, appName);
68
69         return 0;
70 }
71
72
73 static void osrfAppSetOnExit(osrfApplication* app, const char* appName) {
74         if(!(app && appName)) return;
75
76         /* see if we can run the initialize method */
77         char* error;
78         void (*onExit) (void);
79         *(void **) (&onExit) = dlsym(app->handle, "osrfAppChildExit");
80
81         if( (error = dlerror()) != NULL ) {
82                 osrfLogDebug(OSRF_LOG_MARK, "No exit handler defined for %s", appName);
83                 return;
84         }
85
86         osrfLogInfo(OSRF_LOG_MARK, "registering exit handler for %s", appName);
87         app->onExit = (*onExit);
88 }
89
90
91 int osrfAppRunChildInit(const char* appname) {
92         osrfApplication* app = _osrfAppFindApplication(appname);
93         if(!app) return -1;
94
95         char* error;
96         int ret;
97         int (*childInit) (void);
98
99         *(void**) (&childInit) = dlsym(app->handle, "osrfAppChildInit");
100
101         if( (error = dlerror()) != NULL ) {
102                 osrfLogInfo( OSRF_LOG_MARK, "No child init defined for app %s : %s", appname, error);
103                 return 0;
104         }
105
106         if( (ret = (*childInit)()) ) {
107                 osrfLogError(OSRF_LOG_MARK, "App %s child init failed", appname);
108                 return -1;
109         }
110
111         osrfLogInfo(OSRF_LOG_MARK, "%s child init succeeded", appname);
112         return 0;
113 }
114
115
116 void osrfAppRunExitCode() { 
117         osrfHashIterator* itr = osrfNewHashIterator(_osrfAppHash);
118         osrfApplication* app;
119         while( (app = osrfHashIteratorNext(itr)) ) {
120                 if( app->onExit ) {
121                         osrfLogInfo(OSRF_LOG_MARK, "Running onExit handler for app %s",
122                                 osrfHashIteratorKey(itr) );
123                         app->onExit();
124                 }
125         }
126         osrfHashIteratorFree(itr);
127 }
128
129
130 int osrfAppRegisterMethod( const char* appName, const char* methodName, 
131                 const char* symbolName, const char* notes, int argc, int options ) {
132
133         return osrfAppRegisterExtendedMethod(
134                         appName,
135                         methodName,
136                         symbolName,
137                         notes,
138                         argc,
139                         options,
140                         NULL
141         );
142
143 }
144
145 int osrfAppRegisterExtendedMethod( const char* appName, const char* methodName, 
146                 const char* symbolName, const char* notes, int argc, int options, void * user_data ) {
147
148         if( !appName || ! methodName  ) return -1;
149
150         osrfApplication* app = _osrfAppFindApplication(appName);
151         if(!app) {
152                 osrfLogWarning( OSRF_LOG_MARK, "Unable to locate application %s", appName );
153                 return -1;
154         }
155
156         osrfLogDebug( OSRF_LOG_MARK, "Registering method %s for app %s", methodName, appName );
157
158         osrfMethod* method = _osrfAppBuildMethod(
159                 methodName, symbolName, notes, argc, options, user_data );              
160         method->options = options;
161
162         /* plug the method into the list of methods */
163         osrfHashSet( app->methods, method, method->name );
164
165         if( options & OSRF_METHOD_STREAMING ) { /* build the atomic counterpart */
166                 int newops = options | OSRF_METHOD_ATOMIC;
167                 osrfMethod* atomicMethod = _osrfAppBuildMethod(
168                         methodName, symbolName, notes, argc, newops, NULL );            
169                 osrfHashSet( app->methods, atomicMethod, atomicMethod->name );
170                 atomicMethod->userData = method->userData;
171         }
172
173         return 0;
174 }
175
176
177
178 static osrfMethod* _osrfAppBuildMethod( const char* methodName, const char* symbolName,
179                 const char* notes, int argc, int options, void* user_data ) {
180
181         osrfMethod* method                                      = safe_malloc(sizeof(osrfMethod));
182
183         if(methodName) method->name             = strdup(methodName);
184         else method->name    = NULL;
185         if(symbolName) method->symbol           = strdup(symbolName);
186         else method->symbol  = NULL;
187         if(notes) method->notes                         = strdup(notes);
188         else method->notes   = NULL;
189         if(user_data) method->userData  = user_data;
190
191         method->argc                                                    = argc;
192         method->options                                         = options;
193
194         if(options & OSRF_METHOD_ATOMIC) { /* add ".atomic" to the end of the name */
195                 char mb[strlen(method->name) + 8];
196                 sprintf(mb, "%s.atomic", method->name);
197                 free(method->name);
198                 method->name = strdup(mb);
199                 method->options |= OSRF_METHOD_STREAMING;
200         }
201
202         return method;
203 }
204
205
206 /**
207   Registers all of the system methods for this app so that they may be
208   treated the same as other methods */
209 static int _osrfAppRegisterSysMethods( const char* app ) {
210
211         osrfAppRegisterMethod( 
212                         app, OSRF_SYSMETHOD_INTROSPECT, NULL, 
213                         "Return a list of methods whose names have the same initial "
214                         "substring as that of the provided method name PARAMS( methodNameSubstring )", 
215                         1, OSRF_METHOD_SYSTEM | OSRF_METHOD_STREAMING );
216
217         osrfAppRegisterMethod( 
218                         app, OSRF_SYSMETHOD_INTROSPECT_ALL, NULL, 
219                         "Returns a complete list of methods. PARAMS()", 0, 
220                         OSRF_METHOD_SYSTEM | OSRF_METHOD_STREAMING );
221
222         osrfAppRegisterMethod( 
223                         app, OSRF_SYSMETHOD_ECHO, NULL, 
224                         "Echos all data sent to the server back to the client. PARAMS([a, b, ...])", 0, 
225                         OSRF_METHOD_SYSTEM | OSRF_METHOD_STREAMING );
226
227         return 0;
228 }
229
230 /**
231   Finds the given app in the list of apps
232   @param name The name of the application
233   @return The application pointer or NULL if there is no such application
234  */
235 static osrfApplication* _osrfAppFindApplication( const char* name ) {
236         if(!name) return NULL;
237         return (osrfApplication*) osrfHashGet(_osrfAppHash, name);
238 }
239
240 /**
241   Finds the given method for the given app
242   @param app The application object
243   @param methodName The method to find
244   @return A method pointer or NULL if no such method 
245   exists for the given application
246  */
247 static osrfMethod* osrfAppFindMethod( osrfApplication* app, const char* methodName ) {
248         if(!app || ! methodName) return NULL;
249         return (osrfMethod*) osrfHashGet( app->methods, methodName );
250 }
251
252 osrfMethod* _osrfAppFindMethod( const char* appName, const char* methodName ) {
253         if(!appName || ! methodName) return NULL;
254         return osrfAppFindMethod( _osrfAppFindApplication(appName), methodName );
255 }
256
257
258 int osrfAppRunMethod( const char* appName, const char* methodName, 
259                 osrfAppSession* ses, int reqId, jsonObject* params ) {
260
261         if( !(appName && methodName && ses) ) return -1;
262
263         char* error;
264         osrfApplication* app;
265         osrfMethod* method;
266         osrfMethodContext context;
267
268         context.session = ses;
269         context.params = params;
270         context.request = reqId;
271         context.responses = NULL;
272
273         /* this is the method we're gonna run */
274         int (*meth) (osrfMethodContext*);       
275
276         if( !(app = _osrfAppFindApplication(appName)) )
277                 return osrfAppRequestRespondException( ses, 
278                                 reqId, "Application not found: %s", appName );
279         
280         if( !(method = osrfAppFindMethod( app, methodName )) )
281                 return osrfAppRequestRespondException( ses, reqId, 
282                                 "Method [%s] not found for service %s", methodName, appName );
283
284         context.method = method;
285
286         #ifdef OSRF_STRICT_PARAMS
287         if( method->argc > 0 ) {
288                 if(!params || params->type != JSON_ARRAY || params->size < method->argc )
289                         return osrfAppRequestRespondException( ses, reqId, 
290                                 "Not enough params for method %s / service %s", methodName, appName );
291         }
292         #endif
293
294         int retcode = 0;
295
296         if( method->options & OSRF_METHOD_SYSTEM ) {
297                 retcode = _osrfAppRunSystemMethod(&context);
298
299         } else {
300
301                 /* open and now run the method */
302                 *(void **) (&meth) = dlsym(app->handle, method->symbol);
303
304                 if( (error = dlerror()) != NULL ) {
305                         return osrfAppRequestRespondException( ses, reqId, 
306                                 "Unable to execute method [%s]  for service %s", methodName, appName );
307                 }
308
309                 retcode = (*meth) (&context);
310         }
311
312         if(retcode < 0) 
313                 return osrfAppRequestRespondException( 
314                                 ses, reqId, "An unknown server error occurred" );
315
316         return _osrfAppPostProcess( &context, retcode );
317
318 }
319
320
321 int osrfAppRespond( osrfMethodContext* ctx, const jsonObject* data ) {
322         return _osrfAppRespond( ctx, data, 0 );
323 }
324
325 int osrfAppRespondComplete( osrfMethodContext* context, const jsonObject* data ) {
326         return _osrfAppRespond( context, data, 1 );
327 }
328
329 static int _osrfAppRespond( osrfMethodContext* ctx, const jsonObject* data, int complete ) {
330         if(!(ctx && ctx->method)) return -1;
331
332         if( ctx->method->options & OSRF_METHOD_ATOMIC ) {
333                 osrfLogDebug( OSRF_LOG_MARK,   
334                         "Adding responses to stash for atomic method %s", ctx->method->name );
335
336                 if( ctx->responses == NULL )                                                                                            
337                         ctx->responses = jsonParseString("[]");                                                 
338
339                 if ( data != NULL )
340                         jsonObjectPush( ctx->responses, jsonObjectClone(data) );        
341         }
342
343
344         if(     !(ctx->method->options & OSRF_METHOD_ATOMIC) && 
345                         !(ctx->method->options & OSRF_METHOD_CACHABLE) ) {
346
347                 if(complete) 
348                         osrfAppRequestRespondComplete( ctx->session, ctx->request, data );
349                 else
350                         osrfAppRequestRespond( ctx->session, ctx->request, data );
351                 return 0;
352         }
353
354         return 0;
355 }
356
357
358
359
360 static int _osrfAppPostProcess( osrfMethodContext* ctx, int retcode ) {
361         if(!(ctx && ctx->method)) return -1;
362
363         osrfLogDebug( OSRF_LOG_MARK,  "Postprocessing method %s with retcode %d",
364                         ctx->method->name, retcode );
365
366         if(ctx->responses) { /* we have cached responses to return (no responses have been sent) */
367
368                 osrfAppRequestRespondComplete( ctx->session, ctx->request, ctx->responses );
369                 jsonObjectFree(ctx->responses);
370                 ctx->responses = NULL;
371
372         } else {
373
374                 if( retcode > 0 ) 
375                         osrfAppSessionStatus( ctx->session, OSRF_STATUS_COMPLETE,  
376                                         "osrfConnectStatus", ctx->request, "Request Complete" );
377         }
378
379         return 0;
380 }
381
382 int osrfAppRequestRespondException( osrfAppSession* ses, int request, const char* msg, ... ) {
383         if(!ses) return -1;
384         if(!msg) msg = "";
385         VA_LIST_TO_STRING(msg);
386         osrfLogWarning( OSRF_LOG_MARK,  "Returning method exception with message: %s", VA_BUF );
387         osrfAppSessionStatus( ses, OSRF_STATUS_NOTFOUND, "osrfMethodException", request,  VA_BUF );
388         return 0;
389 }
390
391
392 static void _osrfAppSetIntrospectMethod( osrfMethodContext* ctx, const osrfMethod* method, jsonObject* resp ) {
393         if(!(ctx && resp)) return;
394
395         jsonObjectSetKey(resp, "api_name",      jsonNewObject(method->name));
396         jsonObjectSetKey(resp, "method",        jsonNewObject(method->symbol));
397         jsonObjectSetKey(resp, "service",       jsonNewObject(ctx->session->remote_service));
398         jsonObjectSetKey(resp, "notes",         jsonNewObject(method->notes));
399         jsonObjectSetKey(resp, "argc",          jsonNewNumberObject(method->argc));
400
401         jsonObjectSetKey(resp, "sysmethod", 
402                         jsonNewNumberObject( (method->options & OSRF_METHOD_SYSTEM) ? 1 : 0 ));
403         jsonObjectSetKey(resp, "atomic",                
404                         jsonNewNumberObject( (method->options & OSRF_METHOD_ATOMIC) ? 1 : 0 ));
405         jsonObjectSetKey(resp, "cachable",      
406                         jsonNewNumberObject( (method->options & OSRF_METHOD_CACHABLE) ? 1 : 0 ));
407 }
408
409 /**
410   Trys to run the requested method as a system method.
411   A system method is a well known method that all
412   servers implement.  
413   @param context The current method context
414   @return 0 if the method is run successfully, return < 0 means
415   the method was not run, return > 0 means the method was run
416   and the application code now needs to send a 'request complete' 
417   message
418  */
419 static int _osrfAppRunSystemMethod(osrfMethodContext* ctx) {
420         if( osrfMethodVerifyContext( ctx ) < 0 ) {
421                 osrfLogError( OSRF_LOG_MARK,  "_osrfAppRunSystemMethod: Received invalid method context" );
422                 return -1;
423         }
424
425         if(     !strcmp(ctx->method->name, OSRF_SYSMETHOD_INTROSPECT_ALL ) || 
426                         !strcmp(ctx->method->name, OSRF_SYSMETHOD_INTROSPECT_ALL_ATOMIC )) {
427
428                 return osrfAppIntrospectAll(ctx);
429         }
430
431
432         if(     !strcmp(ctx->method->name, OSRF_SYSMETHOD_INTROSPECT ) ||
433                         !strcmp(ctx->method->name, OSRF_SYSMETHOD_INTROSPECT_ATOMIC )) {
434
435                 return osrfAppIntrospect(ctx);
436         }
437
438         if(     !strcmp(ctx->method->name, OSRF_SYSMETHOD_ECHO ) ||
439                         !strcmp(ctx->method->name, OSRF_SYSMETHOD_ECHO_ATOMIC )) {
440
441                 return osrfAppEcho(ctx);
442         }
443
444
445         osrfAppRequestRespondException( ctx->session, 
446                         ctx->request, "System method implementation not found");
447
448         return 0;
449 }
450
451
452 static int osrfAppIntrospect( osrfMethodContext* ctx ) {
453
454         jsonObject* resp = NULL;
455         const char* methodSubstring = jsonObjectGetString( jsonObjectGetIndex(ctx->params, 0) );
456         osrfApplication* app = _osrfAppFindApplication( ctx->session->remote_service );
457         int len = 0;
458
459         if(!methodSubstring) return 1; /* respond with no methods */
460
461         if(app) {
462
463                 osrfHashIterator* itr = osrfNewHashIterator(app->methods);
464                 osrfMethod* method;
465
466                 while( (method = osrfHashIteratorNext(itr)) ) {
467                         if( (len = strlen(methodSubstring)) <= strlen(method->name) ) {
468                                 if( !strncmp( method->name, methodSubstring, len) ) {
469                                         resp = jsonNewObject(NULL);
470                                         _osrfAppSetIntrospectMethod( ctx, method, resp );
471                                         osrfAppRespond(ctx, resp);
472                                         jsonObjectFree(resp);
473                                 }
474                         }
475                 }
476                 osrfHashIteratorFree(itr);
477                 return 1;
478         }
479
480         return -1;
481
482 }
483
484
485 static int osrfAppIntrospectAll( osrfMethodContext* ctx ) {
486         jsonObject* resp = NULL;
487         osrfApplication* app = _osrfAppFindApplication( ctx->session->remote_service );
488
489         if(app) {
490                 osrfHashIterator* itr = osrfNewHashIterator(app->methods);
491                 osrfMethod* method;
492                 while( (method = osrfHashIteratorNext(itr)) ) {
493                         resp = jsonNewObject(NULL);
494                         _osrfAppSetIntrospectMethod( ctx, method, resp );
495                         osrfAppRespond(ctx, resp);
496                         jsonObjectFree(resp);
497                 }
498                 osrfHashIteratorFree(itr);
499                 return 1;
500         }
501
502         return -1;
503 }
504
505 static int osrfAppEcho( osrfMethodContext* ctx ) {
506         if( osrfMethodVerifyContext( ctx ) < 0 ) {
507                 osrfLogError( OSRF_LOG_MARK,  "osrfAppEcho: Received invalid method context" );
508                 return -1;
509         }
510         
511         int i;
512         for( i = 0; i < ctx->params->size; i++ ) {
513                 const jsonObject* str = jsonObjectGetIndex(ctx->params,i);
514                 osrfAppRespond(ctx, str);
515         }
516         return 1;
517 }
518
519 /**
520   Determine whether the context looks healthy.
521   Return 0 if it does, or -1 if it doesn't.
522  */
523 int osrfMethodVerifyContext( osrfMethodContext* ctx )
524 {
525         if( !ctx ) {
526                 osrfLogError( OSRF_LOG_MARK,  "Context is NULL in app request" );
527                 return -1;
528         }
529         
530         if( !ctx->session ) {
531                 osrfLogError( OSRF_LOG_MARK,  "Session is NULL in app request" );
532                 return -1;
533         }
534
535         if( !ctx->method )
536         {
537                 osrfLogError( OSRF_LOG_MARK, "Method is NULL in app request" );
538                 return -1;
539         }
540
541         if( ctx->method->argc ) {
542                 if( !ctx->params ) {
543                         osrfLogError( OSRF_LOG_MARK,
544                                 "Params is NULL in app request %s", ctx->method->name );
545                         return -1;
546                 }
547                 if( ctx->params->type != JSON_ARRAY ) {
548                         osrfLogError( OSRF_LOG_MARK,
549                                 "'params' is not a JSON array for method %s", ctx->method->name );
550                         return -1;
551                 }
552         }
553
554         if( !ctx->method->name ) {
555                 osrfLogError( OSRF_LOG_MARK, "Method name is NULL" );
556                  return -1;
557         }
558
559         // Log the call, with the method and parameters
560         char* params_str = jsonObjectToJSON( ctx->params );
561         if( params_str ) {
562                 osrfLogInfo( OSRF_LOG_MARK, "CALL:      %s %s - %s",
563                          ctx->session->remote_service, ctx->method->name, params_str );
564                 free( params_str );
565         }
566         return 0;
567 }
568