src/pazpar2_config.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 2006-2009 Index Data
   3
   4 Pazpar2 is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 #if HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <string.h>
  25
  26 #include <libxml/parser.h>
  27 #include <libxml/tree.h>
  28 #include <libxslt/xslt.h>
  29 #include <libxslt/transform.h>
  30 #include <libxslt/xsltutils.h>
  31
  32 #include <yaz/yaz-util.h>
  33 #include <yaz/nmem.h>
  34 #include <yaz/snprintf.h>
  35 #include <yaz/tpath.h>
  36
  37 #define CONFIG_NOEXTERNS
  38 #include "pazpar2_config.h"
  39
  40
  41 static NMEM nmem = 0;
  42 static char confdir[256] = ".";
  43
  44 struct conf_config *config = 0;
  45
  46
  47 static
  48 struct conf_metadata * conf_metadata_assign(NMEM nmem,
  49                                             struct conf_metadata * metadata,
  50                                             const char *name,
  51                                             enum conf_metadata_type type,
  52                                             enum conf_metadata_merge merge,
  53                                             enum conf_setting_type setting,
  54                                             int brief,
  55                                             int termlist,
  56                                             int rank,
  57                                             int sortkey_offset,
  58                                             enum conf_metadata_mergekey mt)
  59 {
  60     if (!nmem || !metadata || !name)
  61         return 0;
  62
  63     metadata->name = nmem_strdup(nmem, name);
  64
  65     metadata->type = type;
  66
  67     // enforcing that type_year is always range_merge
  68     if (metadata->type == Metadata_type_year)
  69         metadata->merge = Metadata_merge_range;
  70     else
  71         metadata->merge = merge;
  72
  73     metadata->setting = setting;
  74     metadata->brief = brief;
  75     metadata->termlist = termlist;
  76     metadata->rank = rank;
  77     metadata->sortkey_offset = sortkey_offset;
  78     metadata->mergekey = mt;
  79     return metadata;
  80 }
  81
  82
  83 static
  84 struct conf_sortkey * conf_sortkey_assign(NMEM nmem,
  85                                           struct conf_sortkey * sortkey,
  86                                           const char *name,
  87                                           enum conf_sortkey_type type)
  88 {
  89     if (!nmem || !sortkey || !name)
  90         return 0;
  91
  92     sortkey->name = nmem_strdup(nmem, name);
  93     sortkey->type = type;
  94
  95     return sortkey;
  96 }
  97
  98
  99 struct conf_service * conf_service_create(NMEM nmem,
 100                                           int num_metadata, int num_sortkeys)
 101 {
 102     struct conf_service * service = 0;
 103
 104     //assert(nmem);
 105
 106     service = nmem_malloc(nmem, sizeof(struct conf_service));
 107
 108     service->num_metadata = num_metadata;
 109     service->metadata = 0;
 110     if (service->num_metadata)
 111       service->metadata
 112           = nmem_malloc(nmem,
 113                         sizeof(struct conf_metadata) * service->num_metadata);
 114     service->num_sortkeys = num_sortkeys;
 115     service->sortkeys = 0;
 116     if (service->num_sortkeys)
 117         service->sortkeys
 118             = nmem_malloc(nmem,
 119                           sizeof(struct conf_sortkey) * service->num_sortkeys);
 120
 121     service->nmem = 0;
 122     service->dictionary = 0;
 123     return service;
 124 }
 125
 126 struct conf_metadata* conf_service_add_metadata(NMEM nmem,
 127                                                 struct conf_service *service,
 128                                                 int field_id,
 129                                                 const char *name,
 130                                                 enum conf_metadata_type type,
 131                                                 enum conf_metadata_merge merge,
 132                                                 enum conf_setting_type setting,
 133                                                 int brief,
 134                                                 int termlist,
 135                                                 int rank,
 136                                                 int sortkey_offset,
 137                                                 enum conf_metadata_mergekey mt)
 138 {
 139     struct conf_metadata * md = 0;
 140
 141     if (!service || !service->metadata || !service->num_metadata
 142         || field_id < 0  || !(field_id < service->num_metadata))
 143         return 0;
 144
 145     //md = &((service->metadata)[field_id]);
 146     md = service->metadata + field_id;
 147     md = conf_metadata_assign(nmem, md, name, type, merge, setting,
 148                               brief, termlist, rank, sortkey_offset,
 149                               mt);
 150     return md;
 151 }
 152
 153
 154 struct conf_sortkey * conf_service_add_sortkey(NMEM nmem,
 155                                                struct conf_service *service,
 156                                                int field_id,
 157                                                const char *name,
 158                                                enum conf_sortkey_type type)
 159 {
 160     struct conf_sortkey * sk = 0;
 161
 162     if (!service || !service->sortkeys || !service->num_sortkeys
 163         || field_id < 0  || !(field_id < service->num_sortkeys))
 164         return 0;
 165
 166     //sk = &((service->sortkeys)[field_id]);
 167     sk = service->sortkeys + field_id;
 168     sk = conf_sortkey_assign(nmem, sk, name, type);
 169
 170     return sk;
 171 }
 172
 173
 174 int conf_service_metadata_field_id(struct conf_service *service,
 175                                    const char * name)
 176 {
 177     int i = 0;
 178
 179     if (!service || !service->metadata || !service->num_metadata)
 180         return -1;
 181
 182     for(i = 0; i < service->num_metadata; i++) {
 183         if (!strcmp(name, (service->metadata[i]).name))
 184             return i;
 185     }
 186
 187     return -1;
 188 }
 189
 190
 191 int conf_service_sortkey_field_id(struct conf_service *service,
 192                                   const char * name)
 193 {
 194     int i = 0;
 195
 196     if (!service || !service->sortkeys || !service->num_sortkeys)
 197         return -1;
 198
 199     for(i = 0; i < service->num_sortkeys; i++) {
 200         if (!strcmp(name, (service->sortkeys[i]).name))
 201             return i;
 202     }
 203
 204     return -1;
 205 }
 206
 207
 208
 209 /* Code to parse configuration file */
 210 /* ==================================================== */
 211
 212 static struct conf_service *parse_service(xmlNode *node)
 213 {
 214     xmlNode *n;
 215     int md_node = 0;
 216     int sk_node = 0;
 217
 218     struct conf_service *service = 0;
 219     int num_metadata = 0;
 220     int num_sortkeys = 0;
 221
 222     // count num_metadata and num_sortkeys
 223     for (n = node->children; n; n = n->next)
 224         if (n->type == XML_ELEMENT_NODE && !strcmp((const char *)
 225                                                    n->name, "metadata"))
 226         {
 227             xmlChar *sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 228             num_metadata++;
 229             if (sortkey && strcmp((const char *) sortkey, "no"))
 230                 num_sortkeys++;
 231             xmlFree(sortkey);
 232         }
 233
 234     service = conf_service_create(nmem, num_metadata, num_sortkeys);
 235
 236     for (n = node->children; n; n = n->next)
 237     {
 238         if (n->type != XML_ELEMENT_NODE)
 239             continue;
 240         if (!strcmp((const char *) n->name, (const char *) "metadata"))
 241         {
 242             xmlChar *xml_name = xmlGetProp(n, (xmlChar *) "name");
 243             xmlChar *xml_brief = xmlGetProp(n, (xmlChar *) "brief");
 244             xmlChar *xml_sortkey = xmlGetProp(n, (xmlChar *) "sortkey");
 245             xmlChar *xml_merge = xmlGetProp(n, (xmlChar *) "merge");
 246             xmlChar *xml_type = xmlGetProp(n, (xmlChar *) "type");
 247             xmlChar *xml_termlist = xmlGetProp(n, (xmlChar *) "termlist");
 248             xmlChar *xml_rank = xmlGetProp(n, (xmlChar *) "rank");
 249             xmlChar *xml_setting = xmlGetProp(n, (xmlChar *) "setting");
 250             xmlChar *xml_mergekey = xmlGetProp(n, (xmlChar *) "mergekey");
 251
 252             enum conf_metadata_type type = Metadata_type_generic;
 253             enum conf_metadata_merge merge = Metadata_merge_no;
 254             enum conf_setting_type setting = Metadata_setting_no;
 255             enum conf_sortkey_type sk_type = Metadata_sortkey_relevance;
 256             enum conf_metadata_mergekey mergekey_type = Metadata_mergekey_no;
 257             int brief = 0;
 258             int termlist = 0;
 259             int rank = 0;
 260             int sortkey_offset = 0;
 261
 262             // now do the parsing logic
 263             if (!xml_name)
 264             {
 265                 yaz_log(YLOG_FATAL, "Must specify name in metadata element");
 266                 return 0;
 267             }
 268             if (xml_brief)
 269             {
 270                 if (!strcmp((const char *) xml_brief, "yes"))
 271                     brief = 1;
 272                  else if (strcmp((const char *) xml_brief, "no"))
 273                 {
 274                     yaz_log(YLOG_FATAL, "metadata/brief must be yes or no");
 275                     return 0;
 276                 }
 277             }
 278             else
 279                 brief = 0;
 280
 281             if (xml_termlist)
 282             {
 283                 if (!strcmp((const char *) xml_termlist, "yes"))
 284                     termlist = 1;
 285                 else if (strcmp((const char *) xml_termlist, "no"))
 286                 {
 287                     yaz_log(YLOG_FATAL, "metadata/termlist must be yes or no");
 288                     return 0;
 289                 }
 290             }
 291             else
 292                 termlist = 0;
 293
 294             if (xml_rank)
 295                 rank = atoi((const char *) xml_rank);
 296             else
 297                 rank = 0;
 298
 299             if (xml_type)
 300             {
 301                 if (!strcmp((const char *) xml_type, "generic"))
 302                     type = Metadata_type_generic;
 303                 else if (!strcmp((const char *) xml_type, "year"))
 304                     type = Metadata_type_year;
 305                 else if (!strcmp((const char *) xml_type, "date"))
 306                     type = Metadata_type_date;
 307                 else
 308                 {
 309                     yaz_log(YLOG_FATAL,
 310                             "Unknown value for metadata/type: %s", xml_type);
 311                     return 0;
 312                 }
 313             }
 314             else
 315                 type = Metadata_type_generic;
 316
 317             if (xml_merge)
 318             {
 319                 if (!strcmp((const char *) xml_merge, "no"))
 320                     merge = Metadata_merge_no;
 321                 else if (!strcmp((const char *) xml_merge, "unique"))
 322                     merge = Metadata_merge_unique;
 323                 else if (!strcmp((const char *) xml_merge, "longest"))
 324                     merge = Metadata_merge_longest;
 325                 else if (!strcmp((const char *) xml_merge, "range"))
 326                     merge = Metadata_merge_range;
 327                 else if (!strcmp((const char *) xml_merge, "all"))
 328                     merge = Metadata_merge_all;
 329                 else
 330                 {
 331                     yaz_log(YLOG_FATAL,
 332                             "Unknown value for metadata/merge: %s", xml_merge);
 333                     return 0;
 334                 }
 335             }
 336             else
 337                 merge = Metadata_merge_no;
 338
 339             if (xml_setting)
 340             {
 341                 if (!strcmp((const char *) xml_setting, "no"))
 342                     setting = Metadata_setting_no;
 343                 else if (!strcmp((const char *) xml_setting, "postproc"))
 344                     setting = Metadata_setting_postproc;
 345                 else if (!strcmp((const char *) xml_setting, "parameter"))
 346                     setting = Metadata_setting_parameter;
 347                 else
 348                 {
 349                     yaz_log(YLOG_FATAL,
 350                         "Unknown value for medadata/setting: %s", xml_setting);
 351                     return 0;
 352                 }
 353             }
 354
 355             // add a sortkey if so specified
 356             if (xml_sortkey && strcmp((const char *) xml_sortkey, "no"))
 357             {
 358                 if (merge == Metadata_merge_no)
 359                 {
 360                     yaz_log(YLOG_FATAL,
 361                             "Can't specify sortkey on a non-merged field");
 362                     return 0;
 363                 }
 364                 if (!strcmp((const char *) xml_sortkey, "numeric"))
 365                     sk_type = Metadata_sortkey_numeric;
 366                 else if (!strcmp((const char *) xml_sortkey, "skiparticle"))
 367                     sk_type = Metadata_sortkey_skiparticle;
 368                 else
 369                 {
 370                     yaz_log(YLOG_FATAL,
 371                             "Unknown sortkey in metadata element: %s",
 372                             xml_sortkey);
 373                     return 0;
 374                 }
 375                 sortkey_offset = sk_node;
 376
 377                 conf_service_add_sortkey(nmem, service, sk_node,
 378                                          (const char *) xml_name, sk_type);
 379
 380                 sk_node++;
 381             }
 382             else
 383                 sortkey_offset = -1;
 384
 385             if (xml_mergekey && strcmp((const char *) xml_mergekey, "no"))
 386             {
 387                 mergekey_type = Metadata_mergekey_yes;
 388             }
 389
 390
 391             // metadata known, assign values
 392             conf_service_add_metadata(nmem, service, md_node,
 393                                       (const char *) xml_name,
 394                                       type, merge, setting,
 395                                       brief, termlist, rank, sortkey_offset,
 396                                       mergekey_type);
 397
 398             xmlFree(xml_name);
 399             xmlFree(xml_brief);
 400             xmlFree(xml_sortkey);
 401             xmlFree(xml_merge);
 402             xmlFree(xml_type);
 403             xmlFree(xml_termlist);
 404             xmlFree(xml_rank);
 405             xmlFree(xml_setting);
 406             md_node++;
 407         }
 408         else
 409         {
 410             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 411             return 0;
 412         }
 413     }
 414     return service;
 415 }
 416
 417 static char *parse_settings(xmlNode *node)
 418 {
 419     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 420     char *r;
 421
 422     if (src)
 423     {
 424         if (yaz_is_abspath((const char *) src))
 425             r = nmem_strdup(nmem, (const char *) src);
 426         else
 427         {
 428             r = nmem_malloc(nmem,
 429                             strlen(confdir) + strlen((const char *) src) + 2);
 430             sprintf(r, "%s/%s", confdir, src);
 431         }
 432     }
 433     else
 434     {
 435         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 436         return 0;
 437     }
 438     xmlFree(src);
 439     return r;
 440 }
 441
 442 static struct conf_server *parse_server(xmlNode *node)
 443 {
 444     xmlNode *n;
 445     struct conf_server *server = nmem_malloc(nmem, sizeof(struct conf_server));
 446
 447     server->host = 0;
 448     server->port = 0;
 449     server->proxy_host = 0;
 450     server->proxy_port = 0;
 451     server->myurl = 0;
 452     server->service = 0;
 453     server->next = 0;
 454     server->settings = 0;
 455     server->relevance_pct = 0;
 456     server->sort_pct = 0;
 457     server->mergekey_pct = 0;
 458
 459     for (n = node->children; n; n = n->next)
 460     {
 461         if (n->type != XML_ELEMENT_NODE)
 462             continue;
 463         if (!strcmp((const char *) n->name, "listen"))
 464         {
 465             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 466             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 467             if (port)
 468                 server->port = atoi((const char *) port);
 469             if (host)
 470                 server->host = nmem_strdup(nmem, (const char *) host);
 471             xmlFree(port);
 472             xmlFree(host);
 473         }
 474         else if (!strcmp((const char *) n->name, "proxy"))
 475         {
 476             xmlChar *port = xmlGetProp(n, (xmlChar *) "port");
 477             xmlChar *host = xmlGetProp(n, (xmlChar *) "host");
 478             xmlChar *myurl = xmlGetProp(n, (xmlChar *) "myurl");
 479             if (port)
 480                 server->proxy_port = atoi((const char *) port);
 481             if (host)
 482                 server->proxy_host = nmem_strdup(nmem, (const char *) host);
 483             if (myurl)
 484                 server->myurl = nmem_strdup(nmem, (const char *) myurl);
 485             xmlFree(port);
 486             xmlFree(host);
 487             xmlFree(myurl);
 488         }
 489         else if (!strcmp((const char *) n->name, "settings"))
 490         {
 491             if (server->settings)
 492             {
 493                 yaz_log(YLOG_FATAL, "Can't repeat 'settings'");
 494                 return 0;
 495             }
 496             if (!(server->settings = parse_settings(n)))
 497                 return 0;
 498         }
 499         else if (!strcmp((const char *) n->name, "relevance"))
 500         {
 501             server->relevance_pct = pp2_charset_create_xml(n);
 502             if (!server->relevance_pct)
 503                 return 0;
 504         }
 505         else if (!strcmp((const char *) n->name, "sort"))
 506         {
 507             server->sort_pct = pp2_charset_create_xml(n);
 508             if (!server->sort_pct)
 509                 return 0;
 510         }
 511         else if (!strcmp((const char *) n->name, "mergekey"))
 512         {
 513             server->mergekey_pct = pp2_charset_create_xml(n);
 514             if (!server->mergekey_pct)
 515                 return 0;
 516         }
 517         else if (!strcmp((const char *) n->name, "service"))
 518         {
 519             struct conf_service *s = parse_service(n);
 520             if (!s)
 521                 return 0;
 522             server->service = s;
 523         }
 524         else
 525         {
 526             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 527             return 0;
 528         }
 529     }
 530     if (!server->relevance_pct)
 531         server->relevance_pct = pp2_charset_create(0);
 532     if (!server->sort_pct)
 533         server->sort_pct = pp2_charset_create(0);
 534     if (!server->mergekey_pct)
 535         server->mergekey_pct = pp2_charset_create(0);
 536     return server;
 537 }
 538
 539 xsltStylesheet *conf_load_stylesheet(const char *fname)
 540 {
 541     char path[256];
 542     if (yaz_is_abspath(fname))
 543         yaz_snprintf(path, sizeof(path), fname);
 544     else
 545         yaz_snprintf(path, sizeof(path), "%s/%s", confdir, fname);
 546     return xsltParseStylesheetFile((xmlChar *) path);
 547 }
 548
 549 static struct conf_targetprofiles *parse_targetprofiles(xmlNode *node)
 550 {
 551     struct conf_targetprofiles *r = nmem_malloc(nmem, sizeof(*r));
 552     xmlChar *type = xmlGetProp(node, (xmlChar *) "type");
 553     xmlChar *src = xmlGetProp(node, (xmlChar *) "src");
 554
 555     memset(r, 0, sizeof(*r));
 556
 557     if (type)
 558     {
 559         if (!strcmp((const char *) type, "local"))
 560             r->type = Targetprofiles_local;
 561         else
 562         {
 563             yaz_log(YLOG_FATAL, "Unknown targetprofile type");
 564             return 0;
 565         }
 566     }
 567     else
 568     {
 569         yaz_log(YLOG_FATAL, "Must specify type for targetprofile");
 570         return 0;
 571     }
 572
 573     if (src)
 574         r->src = nmem_strdup(nmem, (const char *) src);
 575     else
 576     {
 577         yaz_log(YLOG_FATAL, "Must specify src in targetprofile");
 578         return 0;
 579     }
 580     xmlFree(type);
 581     xmlFree(src);
 582     return r;
 583 }
 584
 585 static struct conf_config *parse_config(xmlNode *root)
 586 {
 587     xmlNode *n;
 588     struct conf_config *r = nmem_malloc(nmem, sizeof(struct conf_config));
 589
 590     r->servers = 0;
 591     r->targetprofiles = 0;
 592
 593     for (n = root->children; n; n = n->next)
 594     {
 595         if (n->type != XML_ELEMENT_NODE)
 596             continue;
 597         if (!strcmp((const char *) n->name, "server"))
 598         {
 599             struct conf_server *tmp = parse_server(n);
 600             if (!tmp)
 601                 return 0;
 602             tmp->next = r->servers;
 603             r->servers = tmp;
 604         }
 605         else if (!strcmp((const char *) n->name, "targetprofiles"))
 606         {
 607             // It would be fun to be able to fix this sometime
 608             if (r->targetprofiles)
 609             {
 610                 yaz_log(YLOG_FATAL, "Can't repeat targetprofiles");
 611                 return 0;
 612             }
 613             if (!(r->targetprofiles = parse_targetprofiles(n)))
 614                 return 0;
 615         }
 616         else
 617         {
 618             yaz_log(YLOG_FATAL, "Bad element: %s", n->name);
 619             return 0;
 620         }
 621     }
 622     return r;
 623 }
 624
 625 int read_config(const char *fname)
 626 {
 627     xmlDoc *doc = xmlParseFile(fname);
 628     const char *p;
 629
 630     if (!nmem)  // Initialize
 631     {
 632         nmem = nmem_create();
 633         xmlSubstituteEntitiesDefault(1);
 634         xmlLoadExtDtdDefaultValue = 1;
 635     }
 636     if (!doc)
 637     {
 638         yaz_log(YLOG_FATAL, "Failed to read %s", fname);
 639         exit(1);
 640     }
 641     if ((p = strrchr(fname,
 642 #ifdef WIN32
 643                      '\\'
 644 #else
 645                      '/'
 646 #endif
 647              )))
 648     {
 649         int len = p - fname;
 650         if (len >= sizeof(confdir))
 651             len = sizeof(confdir)-1;
 652         strncpy(confdir, fname, len);
 653         confdir[len] = '\0';
 654     }
 655     config = parse_config(xmlDocGetRootElement(doc));
 656     xmlFreeDoc(doc);
 657
 658     if (config)
 659         return 1;
 660     else
 661         return 0;
 662 }
 663
 664
 665 /*
 666  * Local variables:
 667  * c-basic-offset: 4
 668  * c-file-style: "Stroustrup"
 669  * indent-tabs-mode: nil
 670  * End:
 671  * vim: shiftwidth=4 tabstop=8 expandtab
 672  */
 673