Open-ILS/src/c-apps/oils_cstore.c

   1 #include "opensrf/osrf_application.h"
   2 #include "opensrf/osrf_settings.h"
   3 #include "opensrf/utils.h"
   4 #include "objson/object.h"
   5 #include "opensrf/log.h"
   6 #include "oils_utils.h"
   7 #include "oils_constants.h"
   8 #include "oils_event.h"
   9 #include <dbi/dbi.h>
  10
  11 #include <string.h>
  12 #include <libxml/globals.h>
  13 #include <libxml/xmlerror.h>
  14 #include <libxml/parser.h>
  15 #include <libxml/tree.h>
  16 #include <libxml/debugXML.h>
  17 #include <libxml/xmlmemory.h>
  18 //#include <openils/fieldmapper_lookup.h>
  19
  20 #define OILS_AUTH_CACHE_PRFX "oils_cstore_"
  21 #define MODULENAME "open-ils.cstore"
  22 #define PERSIST_NS "http://open-ils.org/spec/opensrf/IDL/persistance/v1"
  23 #define OBJECT_NS "http://open-ils.org/spec/opensrf/IDL/objects/v1"
  24 #define BASE_NS "http://opensrf.org/spec/IDL/base/v1"
  25
  26 int osrfAppChildInit();
  27 int osrfAppInitialize();
  28
  29 int dispatchCRUDMethod ( osrfMethodContext* ctx );
  30 jsonObject* doCreate ( osrfHash* metadata, jsonObject* params );
  31 jsonObject* doRetrieve ( osrfHash* metadata, jsonObject* params );
  32 jsonObject* doUpdate ( osrfHash* metadata, jsonObject* params );
  33 jsonObject* doDelete ( osrfHash* metadata, jsonObject* params );
  34 jsonObject* oilsMakeJSONFromResult( dbi_result result, osrfHash* meta);
  35
  36 dbi_conn dbhandle; /* our db connection */
  37 xmlDocPtr idlDoc = NULL; // parse and store the IDL here
  38
  39 /* handy NULL json object to have around */
  40 static jsonObject* oilsNULL = NULL;
  41
  42 int osrfAppInitialize() {
  43         osrfLogInfo(OSRF_LOG_MARK, "Initializing the CStore Server...");
  44         osrfLogInfo(OSRF_LOG_MARK, "Finding XML file...");
  45
  46         char * idl_filename = osrf_settings_host_value("/apps/%s/app_settings/IDL", MODULENAME);
  47         osrfLogInfo(OSRF_LOG_MARK, "Found file:");
  48         osrfLogInfo(OSRF_LOG_MARK, idl_filename);
  49
  50         osrfLogInfo(OSRF_LOG_MARK, "Parsing the IDL XML...");
  51         idlDoc = xmlReadFile( idl_filename, NULL, XML_PARSE_XINCLUDE );
  52
  53         if (!idlDoc) {
  54                 osrfLogError(OSRF_LOG_MARK, "Could not load or parse the IDL XML file!");
  55                 exit(1);
  56         }
  57
  58         osrfLogInfo(OSRF_LOG_MARK, "...IDL XML parsed");
  59
  60         osrfStringArray* global_methods = osrfNewStringArray(1);
  61
  62         //osrfStringArrayAdd( global_methods, "create" );
  63         osrfStringArrayAdd( global_methods, "retrieve" );
  64         //osrfStringArrayAdd( global_methods, "update" );
  65         //osrfStringArrayAdd( global_methods, "delete" );
  66
  67         xmlNodePtr docRoot = xmlDocGetRootElement(idlDoc);
  68         xmlNodePtr kid = docRoot->children;
  69         while (kid) {
  70                 if (!strcmp( (char*)kid->name, "class" )) {
  71                         int i = 0;
  72                         char* method_type;
  73                         while ( (method_type = osrfStringArrayGetString(global_methods, i)) ) {
  74
  75                                 osrfHash * usrData = osrfNewHash();
  76                                 osrfHashSet( usrData, xmlGetProp(kid, "id"), "classname");
  77                                 osrfHashSet( usrData, xmlGetNsProp(kid, "tablename", PERSIST_NS), "tablename");
  78                                 osrfHashSet( usrData, xmlGetNsProp(kid, "fieldmapper", OBJECT_NS), "fieldmapper");
  79
  80                                 osrfLogInfo(OSRF_LOG_MARK, "Generating class methods for %s", osrfHashGet(usrData, "fieldmapper") );
  81
  82                                 osrfHash* links = osrfNewHash();
  83                                 osrfHash* fields = osrfNewHash();
  84                                 xmlNodePtr _cur = kid->children;
  85
  86                                 while (_cur) {
  87                                         char* string_tmp = NULL;
  88
  89                                         if (!strcmp( (char*)_cur->name, "fields" )) {
  90                                                 xmlNodePtr _f = _cur->children;
  91
  92                                                 while(_f) {
  93                                                         if (strcmp( (char*)_f->name, "field" )) {
  94                                                                 _f = _f->next;
  95                                                                 continue;
  96                                                         }
  97
  98                                                         osrfHash* _tmp = osrfNewHash();
  99
 100                                                         if( (string_tmp = (char*)xmlGetNsProp(_f, "array_position", OBJECT_NS)) ) {
 101                                                                 osrfHashSet(
 102                                                                         _tmp,
 103                                                                         strdup( string_tmp ),
 104                                                                         "array_position"
 105                                                                 );
 106                                                         }
 107                                                         string_tmp = NULL;
 108
 109                                                         char* string_tmp = NULL;
 110                                                         if( (string_tmp = (char*)xmlGetNsProp(_f, "virtual", PERSIST_NS)) ) {
 111                                                                 osrfHashSet(
 112                                                                         _tmp,
 113                                                                         strdup( string_tmp ),
 114                                                                         "virtual"
 115                                                                 );
 116                                                         }
 117                                                         string_tmp = NULL;
 118
 119                                                         if( (string_tmp = (char*)xmlGetProp(_f, "name")) ) {
 120                                                                 osrfHashSet(
 121                                                                         _tmp,
 122                                                                         strdup( string_tmp ),
 123                                                                         "name"
 124                                                                 );
 125                                                         }
 126
 127                                                         osrfLogInfo(OSRF_LOG_MARK, "Found field %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 128
 129                                                         osrfHashSet(
 130                                                                 fields,
 131                                                                 _tmp,
 132                                                                 strdup( string_tmp )
 133                                                         );
 134                                                         _f = _f->next;
 135                                                 }
 136                                         }
 137
 138                                         if (!strcmp( (char*)_cur->name, "links" )) {
 139                                                 xmlNodePtr _l = _cur->children;
 140
 141                                                 while(_l) {
 142                                                         if (strcmp( (char*)_l->name, "link" )) {
 143                                                                 _l = _l->next;
 144                                                                 continue;
 145                                                         }
 146
 147                                                         osrfHash* _tmp = osrfNewHash();
 148
 149                                                         if( (string_tmp = (char*)xmlGetProp(_l, "reltype")) ) {
 150                                                                 osrfHashSet(
 151                                                                         _tmp,
 152                                                                         strdup( string_tmp ),
 153                                                                         "reltype"
 154                                                                 );
 155                                                         }
 156                                                         osrfLogInfo(OSRF_LOG_MARK, "Adding link with reltype %s", string_tmp );
 157                                                         string_tmp = NULL;
 158
 159                                                         if( (string_tmp = (char*)xmlGetProp(_l, "key")) ) {
 160                                                                 osrfHashSet(
 161                                                                         _tmp,
 162                                                                         strdup( string_tmp ),
 163                                                                         "key"
 164                                                                 );
 165                                                         }
 166                                                         osrfLogInfo(OSRF_LOG_MARK, "Link fkey is %s", string_tmp );
 167                                                         string_tmp = NULL;
 168
 169                                                         if( (string_tmp = (char*)xmlGetProp(_l, "class")) ) {
 170                                                                 osrfHashSet(
 171                                                                         _tmp,
 172                                                                         strdup( string_tmp ),
 173                                                                         "class"
 174                                                                 );
 175                                                         }
 176                                                         osrfLogInfo(OSRF_LOG_MARK, "Link fclass is %s", string_tmp );
 177                                                         string_tmp = NULL;
 178
 179                                                         osrfStringArray* map = osrfNewStringArray(0);
 180
 181                                                         if( (string_tmp = (char*)xmlGetProp(_l, "map") )) {
 182                                                                 char* map_list = strdup( string_tmp );
 183                                                                 osrfLogInfo(OSRF_LOG_MARK, "Link mapping list is %s", string_tmp );
 184
 185                                                                 if (strlen( map_list ) > 0) {
 186                                                                         char* st_tmp;
 187                                                                         char* _map_class = strtok_r(map_list, " ", &st_tmp);
 188                                                                         osrfStringArrayAdd(map, strdup(_map_class));
 189
 190                                                                         while ((_map_class = strtok_r(NULL, " ", &st_tmp))) {
 191                                                                                 osrfStringArrayAdd(map, strdup(_map_class));
 192                                                                         }
 193                                                                 }
 194                                                         }
 195                                                         osrfHashSet( _tmp, map, "map");
 196
 197                                                         if( (string_tmp = (char*)xmlGetProp(_l, "field")) ) {
 198                                                                 osrfHashSet(
 199                                                                         _tmp,
 200                                                                         strdup( string_tmp ),
 201                                                                         "field"
 202                                                                 );
 203                                                         }
 204
 205                                                         osrfHashSet(
 206                                                                 links,
 207                                                                 _tmp,
 208                                                                 strdup( string_tmp )
 209                                                         );
 210
 211                                                         osrfLogInfo(OSRF_LOG_MARK, "Found link %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 212
 213                                                         _l = _l->next;
 214                                                 }
 215                                         }
 216
 217                                         _cur = _cur->next;
 218                                 }
 219
 220
 221                                 char* st_tmp;
 222                                 char* _fm;
 223                                 if (!osrfHashGet(usrData, "fieldmapper")) continue;
 224
 225                                 _fm = strdup( (char*)osrfHashGet(usrData, "fieldmapper") );
 226                                 char* part = strtok_r(_fm, ":", &st_tmp);
 227
 228                                 growing_buffer* method_name =  buffer_init(64);
 229                                 buffer_fadd(method_name, "%s.direct.%s", MODULENAME, part);
 230
 231                                 while ((part = strtok_r(NULL, ":", &st_tmp))) {
 232                                         buffer_fadd(method_name, ".%s", part);
 233                                 }
 234                                 buffer_fadd(method_name, ".%s", method_type);
 235
 236                                 char* method = buffer_data(method_name);
 237                                 buffer_free(method_name);
 238
 239                                 osrfHashSet( usrData, method, "methodname" );
 240                                 osrfHashSet( usrData, strdup(method_type), "methodtype" );
 241
 242                                 osrfAppRegisterExtendedMethod(
 243                                         MODULENAME,
 244                                         method,
 245                                         "dispatchCRUDMethod",
 246                                         "",
 247                                         1,
 248                                         0,
 249                                         (void*)usrData
 250                                 );
 251
 252                                 i++;
 253                         }
 254                 }
 255                 kid = kid->next;
 256         }
 257
 258         return 0;
 259 }
 260
 261 /**
 262  * Connects to the database
 263  */
 264 int osrfAppChildInit() {
 265
 266         osrfLogDebug(OSRF_LOG_MARK, "Attempting to initialize libdbi...");
 267         dbi_initialize(NULL);
 268         osrfLogDebug(OSRF_LOG_MARK, "... libdbi initialized.");
 269
 270         char* driver    = osrf_settings_host_value("/apps/%s/app_settings/driver", MODULENAME);
 271         char* user      = osrf_settings_host_value("/apps/%s/app_settings/database/user", MODULENAME);
 272         char* host      = osrf_settings_host_value("/apps/%s/app_settings/database/host", MODULENAME);
 273         char* port      = osrf_settings_host_value("/apps/%s/app_settings/database/port", MODULENAME);
 274         char* db        = osrf_settings_host_value("/apps/%s/app_settings/database/db", MODULENAME);
 275         char* pw        = osrf_settings_host_value("/apps/%s/app_settings/database/pw", MODULENAME);
 276
 277         osrfLogDebug(OSRF_LOG_MARK, "Attempting to load the database driver [%s]...", driver);
 278         dbhandle = dbi_conn_new(driver);
 279
 280         if(!dbhandle) {
 281                 osrfLogError(OSRF_LOG_MARK, "Error loading database driver %s", driver);
 282                 return -1;
 283         }
 284         osrfLogDebug(OSRF_LOG_MARK, "Database driver [%s] seems OK", driver);
 285
 286         osrfLogInfo(OSRF_LOG_MARK, "%s connecting to database.  host=%s, "
 287                 "port=%s, user=%s, pw=%s, db=%s", MODULENAME, host, port, user, pw, db );
 288
 289         if(host) dbi_conn_set_option(dbhandle, "host", host );
 290         if(port) dbi_conn_set_option_numeric( dbhandle, "port", atoi(port) );
 291         if(user) dbi_conn_set_option(dbhandle, "username", user);
 292         if(pw) dbi_conn_set_option(dbhandle, "password", pw );
 293         if(db) dbi_conn_set_option(dbhandle, "dbname", db );
 294
 295         free(user);
 296         free(host);
 297         free(port);
 298         free(db);
 299         free(pw);
 300
 301         const char* err;
 302         if (dbi_conn_connect(dbhandle) < 0) {
 303                 dbi_conn_error(dbhandle, &err);
 304                 osrfLogError( OSRF_LOG_MARK, "Error connecting to database: %s", err);
 305                 return -1;
 306         }
 307
 308         osrfLogInfo(OSRF_LOG_MARK, "%s successfully connected to the database", MODULENAME);
 309
 310         return 0;
 311 }
 312
 313
 314 int dispatchCRUDMethod ( osrfMethodContext* ctx ) {
 315         OSRF_METHOD_VERIFY_CONTEXT(ctx);
 316
 317         osrfHash* meta = (osrfHash*) ctx->method->userData;
 318
 319         jsonObject * obj = NULL;
 320         if (!strcmp( (char*)osrfHashGet(meta, "methodtype"), "create"))
 321                 obj = doCreate(meta, ctx->params);
 322
 323         if (!strcmp( (char*)osrfHashGet(meta, "methodtype"), "retrieve"))
 324                 obj = doRetrieve(meta, ctx->params);
 325
 326         if (!strcmp( (char*)osrfHashGet(meta, "methodtype"), "update"))
 327                 obj = doUpdate(meta, ctx->params);
 328
 329         if (!strcmp( (char*)osrfHashGet(meta, "methodtype"), "delete"))
 330                 obj = doDelete(meta, ctx->params);
 331
 332         osrfAppRespondComplete( ctx, obj );
 333
 334         jsonObjectFree(obj);
 335
 336         return 0;
 337 }
 338
 339 jsonObject* doCreate( osrfHash* meta, jsonObject* params ) { return NULL; }
 340
 341 jsonObject* doRetrieve( osrfHash* meta, jsonObject* params ) {
 342
 343         char* id        = jsonObjectToSimpleString(jsonObjectGetIndex(params, 0));
 344
 345         osrfLogDebug(
 346                 OSRF_LOG_MARK,
 347                 "%s retrieving %s object with id %s",
 348                 MODULENAME,
 349                 osrfHashGet(meta, "fieldmapper"),
 350                 id
 351         );
 352
 353
 354
 355         growing_buffer* sql_buf = buffer_init(128);
 356         buffer_fadd(
 357                 sql_buf,
 358                 "SELECT * FROM %s WHERE %s = %d;",
 359                 osrfHashGet(meta, "tablename"),
 360                 xmlGetNsProp( (xmlNode*)osrfHashGet(meta, "fields"), "primary", "http://open-ils.org/spec/opensrf/IDL/persistance/v1" ),
 361                 atoi(id)
 362         );
 363
 364         char* sql = buffer_data(sql_buf);
 365         buffer_free(sql_buf);
 366
 367         osrfLogDebug(OSRF_LOG_MARK, "%s SQL =  %s", MODULENAME, sql);
 368
 369         dbi_result result = dbi_conn_query(dbhandle, sql);
 370
 371         jsonObject* obj = NULL;
 372         if(result) {
 373
 374                 /* there should be one row at the most  */
 375                 if (!dbi_result_first_row(result)) {
 376                         osrfLogDebug(OSRF_LOG_MARK, "%s: Error retrieving %s with key %s", MODULENAME, osrfHashGet(meta, "fieldmapper"), id);
 377                         dbi_result_free(result);
 378                         return oilsNULL;
 379                 }
 380
 381                 /* JSONify the result */
 382                 obj = oilsMakeJSONFromResult( result, meta );
 383
 384                 /* clean up the query */
 385                 dbi_result_free(result);
 386
 387         } else {
 388                 osrfLogDebug(OSRF_LOG_MARK, "%s returned no results for query %s", MODULENAME, sql);
 389         }
 390
 391         free(id);
 392
 393         return obj;
 394 }
 395
 396
 397 jsonObject* doUpdate( osrfHash* meta, jsonObject* params ) { return NULL; }
 398
 399 jsonObject* doDelete( osrfHash* meta, jsonObject* params ) { return NULL; }
 400
 401
 402 jsonObject* oilsMakeJSONFromResult( dbi_result result, osrfHash* meta) {
 403         if(!(result && meta)) return NULL;
 404
 405         jsonObject* object = jsonParseString("[]");
 406         jsonObjectSetClass(object, osrfHashGet(meta, "classname"));
 407
 408         osrfHash* fields = osrfHashGet(meta, "fields");
 409
 410         osrfHash* _f;
 411         int attr;
 412         int fmIndex;
 413         int columnIndex = 1;
 414         unsigned short type;
 415         const char* columnName;
 416
 417         /* cycle through the column list */
 418         while( (columnName = dbi_result_get_field_name(result, columnIndex++)) ) {
 419
 420                 fmIndex = -1; // reset the position
 421
 422                 /* determine the field type and storage attributes */
 423                 type = dbi_result_get_field_type(result, columnName);
 424                 attr = dbi_result_get_field_attribs(result, columnName);
 425
 426                 /* fetch the fieldmapper index */
 427                 if( (_f = osrfHashGet(fields, (char*)columnName)) ) {
 428                         if ( !(strcmp( osrfHashGet(_f, "virtual"), "true" )) ) continue;
 429                         if ( !(stringisnum( osrfHashGet(_f, "array_position") )) ) continue;
 430                         fmIndex = atoi(osrfHashGet(_f, "array_position"));
 431                 }
 432
 433                 switch( type ) {
 434
 435                         case DBI_TYPE_INTEGER :
 436
 437                                 if( attr & DBI_INTEGER_SIZE8 )
 438                                         jsonObjectSetIndex( object, fmIndex,
 439                                                 jsonNewNumberObject(dbi_result_get_longlong(result, columnName)));
 440                                 else
 441                                         jsonObjectSetIndex( object, fmIndex,
 442                                                 jsonNewNumberObject(dbi_result_get_long(result, columnName)));
 443
 444                                 break;
 445
 446                         case DBI_TYPE_DECIMAL :
 447                                 jsonObjectSetIndex( object, fmIndex,
 448                                                 jsonNewNumberObject(dbi_result_get_double(result, columnName)));
 449                                 break;
 450
 451                         case DBI_TYPE_STRING :
 452                                 jsonObjectSetIndex( object, fmIndex,
 453                                         jsonNewObject(dbi_result_get_string(result, columnName)));
 454                                 break;
 455
 456                         case DBI_TYPE_DATETIME :
 457                                 jsonObjectSetIndex( object, fmIndex,
 458                                         jsonNewNumberObject(dbi_result_get_datetime(result, columnName)));
 459                                 break;
 460
 461                         case DBI_TYPE_BINARY :
 462                                 osrfLogError( OSRF_LOG_MARK,
 463                                         "Can't do binary at column %s : index %d", columnName, columnIndex - 1);
 464                 }
 465         }
 466
 467         return object;
 468 }
 469
 470
 471
 472