index/zebraapi.c

   1 /*
   2  * Copyright (C) 1995-2002, Index Data
   3  * All rights reserved.
   4  *
   5  * $Id: zebraapi.c,v 1.55 2002-04-15 13:48:11 adam Exp $
   6  */
   7
   8 #include <assert.h>
   9 #include <stdio.h>
  10 #ifdef WIN32
  11 #include <io.h>
  12 #include <process.h>
  13 #include <direct.h>
  14 #else
  15 #include <unistd.h>
  16 #endif
  17
  18 #include <yaz/diagbib1.h>
  19 #include "index.h"
  20 #include <charmap.h>
  21
  22 static Res zebra_open_res (ZebraHandle zh);
  23 static void zebra_close_res (ZebraHandle zh);
  24
  25 static void zebra_chdir (ZebraService zh)
  26 {
  27     const char *dir = res_get (zh->global_res, "chdir");
  28     if (!dir)
  29         return;
  30     logf (LOG_DEBUG, "chdir %s", dir);
  31 #ifdef WIN32
  32     _chdir(dir);
  33 #else
  34     chdir (dir);
  35 #endif
  36 }
  37
  38 static void zebra_flush_reg (ZebraHandle zh)
  39 {
  40     zebraExplain_flush (zh->reg->zei, 1, zh);
  41
  42     extract_flushWriteKeys (zh);
  43     zebra_index_merge (zh);
  44 }
  45
  46 static struct zebra_register *zebra_register_open (ZebraService zs,
  47                                                    const char *name,
  48                                                    int rw, int useshadow,
  49                                                    Res res,
  50                                                    const char *reg_path);
  51 static void zebra_register_close (ZebraService zs, struct zebra_register *reg);
  52
  53 static int zebra_begin_read (ZebraHandle zh);
  54 static void zebra_end_read (ZebraHandle zh);
  55
  56 ZebraHandle zebra_open (ZebraService zs)
  57 {
  58     ZebraHandle zh;
  59
  60     if (!zs)
  61         return 0;
  62
  63     zh = (ZebraHandle) xmalloc (sizeof(*zh));
  64     yaz_log (LOG_LOG, "zebra_open zs=%p returns %p", zs, zh);
  65
  66     zh->service = zs;
  67     zh->reg = 0;          /* no register attached yet */
  68     zh->sets = 0;
  69     zh->destroyed = 0;
  70     zh->errCode = 0;
  71     zh->errString = 0;
  72     zh->res = 0;
  73
  74     zh->reg_name = xstrdup ("");
  75     zh->path_reg = 0;
  76     zh->num_basenames = 0;
  77     zh->basenames = 0;
  78
  79     zh->trans_no = 0;
  80
  81     zh->lock_normal = 0;
  82     zh->lock_shadow = 0;
  83
  84     zh->admin_databaseName = 0;
  85
  86     zh->shadow_enable = 1;
  87
  88     zebra_mutex_cond_lock (&zs->session_lock);
  89
  90     zh->next = zs->sessions;
  91     zs->sessions = zh;
  92
  93     zebra_mutex_cond_unlock (&zs->session_lock);
  94
  95     return zh;
  96 }
  97
  98 ZebraService zebra_start (const char *configName)
  99 {
 100     Res res;
 101
 102     yaz_log (LOG_LOG, "zebra_start %s", configName);
 103
 104     if (!(res = res_open (configName, 0)))
 105         yaz_log (LOG_WARN, "Cannot read resources `%s'", configName);
 106     else
 107     {
 108         ZebraService zh = xmalloc (sizeof(*zh));
 109
 110         yaz_log (LOG_LOG, "Read resources `%s'", configName);
 111
 112         zh->global_res = res;
 113         zh->configName = xstrdup(configName);
 114         zh->sessions = 0;
 115
 116         zebra_chdir (zh);
 117
 118         zebra_mutex_cond_init (&zh->session_lock);
 119         if (!res_get (zh->global_res, "passwd"))
 120             zh->passwd_db = NULL;
 121         else
 122         {
 123             zh->passwd_db = passwd_db_open ();
 124             if (!zh->passwd_db)
 125                 logf (LOG_WARN|LOG_ERRNO, "passwd_db_open failed");
 126             else
 127                 passwd_db_file (zh->passwd_db,
 128                                 res_get (zh->global_res, "passwd"));
 129         }
 130         zh->path_root = res_get (zh->global_res, "root");
 131         return zh;
 132     }
 133     return 0;
 134 }
 135
 136 static
 137 struct zebra_register *zebra_register_open (ZebraService zs, const char *name,
 138                                             int rw, int useshadow, Res res,
 139                                             const char *reg_path)
 140 {
 141     struct zebra_register *reg;
 142     int record_compression = REC_COMPRESS_NONE;
 143     char *recordCompression = 0;
 144
 145     reg = xmalloc (sizeof(*reg));
 146
 147     assert (name);
 148     reg->name = xstrdup (name);
 149
 150     reg->seqno = 0;
 151     reg->last_val = 0;
 152
 153     assert (res);
 154
 155     yaz_log (LOG_LOG, "zebra_register_open rw = %d useshadow=%d p=%p",
 156              rw, useshadow, reg);
 157
 158     reg->dh = data1_create ();
 159     if (!reg->dh)
 160         return 0;
 161     reg->bfs = bfs_create (res_get (res, "register"), reg_path);
 162     if (!reg->bfs)
 163     {
 164         data1_destroy(reg->dh);
 165         return 0;
 166     }
 167     if (useshadow)
 168         bf_cache (reg->bfs, res_get (res, "shadow"));
 169     data1_set_tabpath (reg->dh, res_get(res, "profilePath"));
 170     data1_set_tabroot (reg->dh, reg_path);
 171     reg->recTypes = recTypes_init (reg->dh);
 172     recTypes_default_handlers (reg->recTypes);
 173
 174     reg->zebra_maps = zebra_maps_open (res, reg_path);
 175     reg->rank_classes = NULL;
 176
 177     reg->key_buf = 0;
 178
 179     reg->keys.buf_max = 0;
 180     reg->keys.buf = 0;
 181
 182     reg->records = 0;
 183     reg->dict = 0;
 184     reg->sortIdx = 0;
 185     reg->isams = 0;
 186     reg->matchDict = 0;
 187     reg->isam = 0;
 188     reg->isamc = 0;
 189     reg->isamd = 0;
 190     reg->zei = 0;
 191     reg->matchDict = 0;
 192
 193     zebraRankInstall (reg, rank1_class);
 194
 195     recordCompression = res_get_def (res, "recordCompression", "none");
 196     if (!strcmp (recordCompression, "none"))
 197         record_compression = REC_COMPRESS_NONE;
 198     if (!strcmp (recordCompression, "bzip2"))
 199         record_compression = REC_COMPRESS_BZIP2;
 200
 201     if (!(reg->records = rec_open (reg->bfs, rw, record_compression)))
 202     {
 203         logf (LOG_WARN, "rec_open");
 204         return 0;
 205     }
 206     if (rw)
 207     {
 208         reg->matchDict = dict_open (reg->bfs, GMATCH_DICT, 20, 1, 0);
 209     }
 210     if (!(reg->dict = dict_open (reg->bfs, FNAME_DICT, 40, rw, 0)))
 211     {
 212         logf (LOG_WARN, "dict_open");
 213         return 0;
 214     }
 215     if (!(reg->sortIdx = sortIdx_open (reg->bfs, rw)))
 216     {
 217         logf (LOG_WARN, "sortIdx_open");
 218         return 0;
 219     }
 220     if (res_get_match (res, "isam", "s", ISAM_DEFAULT))
 221     {
 222         struct ISAMS_M_s isams_m;
 223         if (!(reg->isams = isams_open (reg->bfs, FNAME_ISAMS, rw,
 224                                       key_isams_m(res, &isams_m))))
 225         {
 226             logf (LOG_WARN, "isams_open");
 227             return 0;
 228         }
 229     }
 230     else if (res_get_match (res, "isam", "i", ISAM_DEFAULT))
 231     {
 232         if (!(reg->isam = is_open (reg->bfs, FNAME_ISAM, key_compare, rw,
 233                                   sizeof (struct it_key), res)))
 234         {
 235             logf (LOG_WARN, "is_open");
 236             return 0;
 237         }
 238     }
 239     else if (res_get_match (res, "isam", "c", ISAM_DEFAULT))
 240     {
 241         struct ISAMC_M_s isamc_m;
 242         if (!(reg->isamc = isc_open (reg->bfs, FNAME_ISAMC,
 243                                     rw, key_isamc_m(res, &isamc_m))))
 244         {
 245             logf (LOG_WARN, "isc_open");
 246             return 0;
 247         }
 248     }
 249     else if (res_get_match (res, "isam", "d", ISAM_DEFAULT))
 250     {
 251         struct ISAMD_M_s isamd_m;
 252
 253         if (!(reg->isamd = isamd_open (reg->bfs, FNAME_ISAMD,
 254                                       rw, key_isamd_m(res, &isamd_m))))
 255         {
 256             logf (LOG_WARN, "isamd_open");
 257             return 0;
 258         }
 259     }
 260     reg->zei = zebraExplain_open (reg->records, reg->dh,
 261                                   res, rw, reg,
 262                                   explain_extract);
 263     if (!reg->zei)
 264     {
 265         logf (LOG_WARN, "Cannot obtain EXPLAIN information");
 266         return 0;
 267     }
 268     reg->active = 2;
 269     yaz_log (LOG_LOG, "zebra_register_open ok p=%p", reg);
 270     return reg;
 271 }
 272
 273 void zebra_admin_shutdown (ZebraHandle zh)
 274 {
 275     zebra_mutex_cond_lock (&zh->service->session_lock);
 276     zh->service->stop_flag = 1;
 277     zebra_mutex_cond_unlock (&zh->service->session_lock);
 278 }
 279
 280 void zebra_admin_start (ZebraHandle zh)
 281 {
 282     ZebraService zs = zh->service;
 283     zh->errCode = 0;
 284     zebra_mutex_cond_lock (&zs->session_lock);
 285     zebra_mutex_cond_unlock (&zs->session_lock);
 286 }
 287
 288 static void zebra_register_close (ZebraService zs, struct zebra_register *reg)
 289 {
 290     yaz_log(LOG_LOG, "zebra_register_close p=%p", reg);
 291     reg->stop_flag = 0;
 292     zebra_chdir (zs);
 293     if (reg->records)
 294     {
 295         zebraExplain_close (reg->zei, 0);
 296         dict_close (reg->dict);
 297         if (reg->matchDict)
 298             dict_close (reg->matchDict);
 299         sortIdx_close (reg->sortIdx);
 300         if (reg->isams)
 301             isams_close (reg->isams);
 302         if (reg->isam)
 303             is_close (reg->isam);
 304         if (reg->isamc)
 305             isc_close (reg->isamc);
 306         if (reg->isamd)
 307             isamd_close (reg->isamd);
 308         rec_close (&reg->records);
 309     }
 310
 311     recTypes_destroy (reg->recTypes);
 312     zebra_maps_close (reg->zebra_maps);
 313     zebraRankDestroy (reg);
 314     bfs_destroy (reg->bfs);
 315     data1_destroy (reg->dh);
 316
 317     xfree (reg->key_buf);
 318     xfree (reg->name);
 319     xfree (reg);
 320     yaz_log (LOG_LOG, "zebra_register_close 2");
 321 }
 322
 323 void zebra_stop(ZebraService zs)
 324 {
 325     if (!zs)
 326         return ;
 327     yaz_log (LOG_LOG, "zebra_stop");
 328
 329     zebra_mutex_cond_lock (&zs->session_lock);
 330     while (zs->sessions)
 331     {
 332         zebra_close (zs->sessions);
 333     }
 334
 335     zebra_mutex_cond_unlock (&zs->session_lock);
 336
 337     zebra_mutex_cond_destroy (&zs->session_lock);
 338
 339     if (zs->passwd_db)
 340         passwd_db_close (zs->passwd_db);
 341
 342     res_close (zs->global_res);
 343     xfree (zs->configName);
 344     xfree (zs->path_root);
 345     xfree (zs);
 346 }
 347
 348 void zebra_close (ZebraHandle zh)
 349 {
 350     ZebraService zs;
 351     struct zebra_session **sp;
 352
 353     if (!zh)
 354         return;
 355
 356     zs = zh->service;
 357     yaz_log (LOG_LOG, "zebra_close zh=%p", zh);
 358     if (!zh)
 359         return ;
 360     resultSetDestroy (zh, -1, 0, 0);
 361
 362
 363     if (zh->reg)
 364         zebra_register_close (zh->service, zh->reg);
 365     zebra_close_res (zh);
 366
 367     xfree (zh->admin_databaseName);
 368     zebra_mutex_cond_lock (&zs->session_lock);
 369     zebra_lock_destroy (zh->lock_normal);
 370     zebra_lock_destroy (zh->lock_shadow);
 371     sp = &zs->sessions;
 372     while (1)
 373     {
 374         assert (*sp);
 375         if (*sp == zh)
 376         {
 377             *sp = (*sp)->next;
 378             break;
 379         }
 380         sp = &(*sp)->next;
 381     }
 382 //    if (!zs->sessions && zs->stop_flag)
 383 //      zebra_register_deactivate(zs);
 384     zebra_mutex_cond_unlock (&zs->session_lock);
 385     xfree (zh->reg_name);
 386     xfree (zh);
 387     yaz_log (LOG_LOG, "zebra_close zh=%p end", zh);}
 388
 389 struct map_baseinfo {
 390     ZebraHandle zh;
 391     NMEM mem;
 392     int num_bases;
 393     char **basenames;
 394     int new_num_bases;
 395     char **new_basenames;
 396     int new_num_max;
 397 };
 398
 399 static Res zebra_open_res (ZebraHandle zh)
 400 {
 401     Res res = 0;
 402     char fname[512];
 403     if (zh->path_reg)
 404     {
 405         sprintf (fname, "%.200s/zebra.cfg", zh->path_reg);
 406         res = res_open (fname, zh->service->global_res);
 407         if (!res)
 408             res = zh->service->global_res;
 409     }
 410     else if (*zh->reg_name == 0)
 411     {
 412         res = zh->service->global_res;
 413     }
 414     else
 415     {
 416         yaz_log (LOG_WARN, "no register root specified");
 417         return 0;  /* no path for register - fail! */
 418     }
 419     return res;
 420 }
 421
 422 static void zebra_close_res (ZebraHandle zh)
 423 {
 424     if (zh->res != zh->service->global_res)
 425         res_close (zh->res);
 426     zh->res = 0;
 427 }
 428
 429 static int zebra_select_register (ZebraHandle zh, const char *new_reg)
 430 {
 431     if (zh->res && strcmp (zh->reg_name, new_reg) == 0)
 432         return 0;
 433     if (!zh->res)
 434     {
 435         assert (zh->reg == 0);
 436         assert (*zh->reg_name == 0);
 437     }
 438     else
 439     {
 440         if (zh->reg)
 441         {
 442             resultSetInvalidate (zh);
 443             zebra_register_close (zh->service, zh->reg);
 444             zh->reg = 0;
 445         }
 446         zebra_close_res(zh);
 447     }
 448     xfree (zh->reg_name);
 449     zh->reg_name = xstrdup (new_reg);
 450
 451     xfree (zh->path_reg);
 452     zh->path_reg = 0;
 453     if (zh->service->path_root)
 454     {
 455         zh->path_reg = xmalloc (strlen(zh->service->path_root) +
 456                                 strlen(zh->reg_name) + 3);
 457         strcpy (zh->path_reg, zh->service->path_root);
 458         if (*zh->reg_name)
 459         {
 460             strcat (zh->path_reg, "/");
 461             strcat (zh->path_reg, zh->reg_name);
 462         }
 463     }
 464     zh->res = zebra_open_res (zh);
 465
 466     if (zh->lock_normal)
 467         zebra_lock_destroy (zh->lock_normal);
 468     zh->lock_normal = 0;
 469
 470     if (zh->lock_shadow)
 471         zebra_lock_destroy (zh->lock_shadow);
 472     zh->lock_shadow = 0;
 473
 474     if (zh->res)
 475     {
 476         char fname[512];
 477         const char *lock_area  =res_get (zh->res, "lockDir");
 478
 479         if (!lock_area && zh->path_reg)
 480             res_put (zh->res, "lockDir", zh->path_reg);
 481         sprintf (fname, "norm.%s.LCK", zh->reg_name);
 482         zh->lock_normal =
 483             zebra_lock_create (res_get(zh->res, "lockDir"), fname, 0);
 484
 485         sprintf (fname, "shadow.%s.LCK", zh->reg_name);
 486         zh->lock_shadow =
 487             zebra_lock_create (res_get(zh->res, "lockDir"), fname, 0);
 488
 489     }
 490     return 1;
 491 }
 492
 493 void map_basenames_func (void *vp, const char *name, const char *value)
 494 {
 495     struct map_baseinfo *p = (struct map_baseinfo *) vp;
 496     int i, no;
 497     char fromdb[128], todb[8][128];
 498
 499     no =
 500         sscanf (value, "%127s %127s %127s %127s %127s %127s %127s %127s %127s",
 501                 fromdb, todb[0], todb[1], todb[2], todb[3], todb[4],
 502                 todb[5], todb[6], todb[7]);
 503     if (no < 2)
 504         return ;
 505     no--;
 506     for (i = 0; i<p->num_bases; i++)
 507         if (p->basenames[i] && !strcmp (p->basenames[i], fromdb))
 508         {
 509             p->basenames[i] = 0;
 510             for (i = 0; i < no; i++)
 511             {
 512                 if (p->new_num_bases == p->new_num_max)
 513                     return;
 514                 p->new_basenames[(p->new_num_bases)++] =
 515                     nmem_strdup (p->mem, todb[i]);
 516             }
 517             return;
 518         }
 519 }
 520
 521 void map_basenames (ZebraHandle zh, ODR stream,
 522                     int *num_bases, char ***basenames)
 523 {
 524     struct map_baseinfo info;
 525     struct map_baseinfo *p = &info;
 526     int i;
 527
 528     info.zh = zh;
 529     info.num_bases = *num_bases;
 530     info.basenames = *basenames;
 531     info.new_num_max = 128;
 532     info.new_num_bases = 0;
 533     info.new_basenames = (char **)
 534         odr_malloc (stream, sizeof(*info.new_basenames) * info.new_num_max);
 535     info.mem = stream->mem;
 536
 537     res_trav (zh->service->global_res, "mapdb", &info, map_basenames_func);
 538
 539     for (i = 0; i<p->num_bases; i++)
 540         if (p->basenames[i] && p->new_num_bases < p->new_num_max)
 541         {
 542             p->new_basenames[(p->new_num_bases)++] =
 543                 nmem_strdup (p->mem, p->basenames[i]);
 544         }
 545     *num_bases = info.new_num_bases;
 546     *basenames = info.new_basenames;
 547     for (i = 0; i<*num_bases; i++)
 548         logf (LOG_LOG, "base %s", (*basenames)[i]);
 549 }
 550
 551 int zebra_select_database (ZebraHandle zh, const char *basename)
 552 {
 553     return zebra_select_databases (zh, 1, &basename);
 554 }
 555
 556 int zebra_select_databases (ZebraHandle zh, int num_bases,
 557                             const char **basenames)
 558 {
 559     int i;
 560     const char *cp;
 561     int len = 0;
 562     char *new_reg = 0;
 563
 564     if (num_bases < 1)
 565     {
 566         zh->errCode = 23;
 567         return -1;
 568     }
 569     for (i = 0; i < zh->num_basenames; i++)
 570         xfree (zh->basenames[i]);
 571     xfree (zh->basenames);
 572
 573     zh->num_basenames = num_bases;
 574     zh->basenames = xmalloc (zh->num_basenames * sizeof(*zh->basenames));
 575     for (i = 0; i < zh->num_basenames; i++)
 576         zh->basenames[i] = xstrdup (basenames[i]);
 577
 578     cp = strrchr(basenames[0], '/');
 579     if (cp)
 580     {
 581         len = cp - basenames[0];
 582         new_reg = xmalloc (len + 1);
 583         memcpy (new_reg, basenames[0], len);
 584         new_reg[len] = '\0';
 585     }
 586     else
 587         new_reg = xstrdup ("");
 588     for (i = 1; i<num_bases; i++)
 589     {
 590         const char *cp1;
 591
 592         cp1 = strrchr (basenames[i], '/');
 593         if (cp)
 594         {
 595             if (!cp1)
 596             {
 597                 zh->errCode = 23;
 598                 return -1;
 599             }
 600             if (len != cp1 - basenames[i] ||
 601                 memcmp (basenames[i], new_reg, len))
 602             {
 603                 zh->errCode = 23;
 604                 return -1;
 605             }
 606         }
 607         else
 608         {
 609             if (cp1)
 610             {
 611                 zh->errCode = 23;
 612                 return -1;
 613             }
 614         }
 615     }
 616     zebra_select_register (zh, new_reg);
 617     xfree (new_reg);
 618     if (!zh->res)
 619     {
 620         zh->errCode = 109;
 621         return -1;
 622     }
 623     return 0;
 624 }
 625
 626 void zebra_search_rpn (ZebraHandle zh, ODR decode, ODR stream,
 627                        Z_RPNQuery *query, const char *setname, int *hits)
 628 {
 629     zh->hits = 0;
 630     *hits = 0;
 631
 632     if (zebra_begin_read (zh))
 633         return;
 634     resultSetAddRPN (zh, decode, stream, query,
 635                      zh->num_basenames, zh->basenames, setname);
 636
 637     zebra_end_read (zh);
 638
 639     *hits = zh->hits;
 640 }
 641
 642 void zebra_records_retrieve (ZebraHandle zh, ODR stream,
 643                              const char *setname, Z_RecordComposition *comp,
 644                              oid_value input_format, int num_recs,
 645                              ZebraRetrievalRecord *recs)
 646 {
 647     ZebraPosSet poset;
 648     int i, *pos_array;
 649
 650     if (!zh->res)
 651     {
 652         zh->errCode = 30;
 653         zh->errString = odr_strdup (stream, setname);
 654         return;
 655     }
 656
 657     if (zebra_begin_read (zh))
 658         return;
 659
 660     pos_array = (int *) xmalloc (num_recs * sizeof(*pos_array));
 661     for (i = 0; i<num_recs; i++)
 662         pos_array[i] = recs[i].position;
 663     poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
 664     if (!poset)
 665     {
 666         logf (LOG_DEBUG, "zebraPosSetCreate error");
 667         zh->errCode = 30;
 668         zh->errString = nmem_strdup (stream->mem, setname);
 669     }
 670     else
 671     {
 672         for (i = 0; i<num_recs; i++)
 673         {
 674             if (poset[i].term)
 675             {
 676                 recs[i].errCode = 0;
 677                 recs[i].format = VAL_SUTRS;
 678                 recs[i].len = strlen(poset[i].term);
 679                 recs[i].buf = poset[i].term;
 680                 recs[i].base = poset[i].db;
 681             }
 682             else if (poset[i].sysno)
 683             {
 684                 recs[i].errCode =
 685                     zebra_record_fetch (zh, poset[i].sysno, poset[i].score,
 686                                         stream, input_format, comp,
 687                                         &recs[i].format, &recs[i].buf,
 688                                         &recs[i].len,
 689                                         &recs[i].base);
 690                 recs[i].errString = NULL;
 691             }
 692             else
 693             {
 694                 char num_str[20];
 695
 696                 sprintf (num_str, "%d", pos_array[i]);
 697                 zh->errCode = 13;
 698                 zh->errString = odr_strdup (stream, num_str);
 699                 break;
 700             }
 701         }
 702         zebraPosSetDestroy (zh, poset, num_recs);
 703     }
 704     zebra_end_read (zh);
 705     xfree (pos_array);
 706 }
 707
 708 void zebra_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
 709                  oid_value attributeset,
 710                  int *position, int *num_entries, ZebraScanEntry **entries,
 711                  int *is_partial)
 712 {
 713     if (zebra_begin_read (zh))
 714     {
 715         *entries = 0;
 716         *num_entries = 0;
 717         return;
 718     }
 719     rpn_scan (zh, stream, zapt, attributeset,
 720               zh->num_basenames, zh->basenames, position,
 721               num_entries, entries, is_partial);
 722     zebra_end_read (zh);
 723 }
 724
 725 void zebra_sort (ZebraHandle zh, ODR stream,
 726                  int num_input_setnames, const char **input_setnames,
 727                  const char *output_setname, Z_SortKeySpecList *sort_sequence,
 728                  int *sort_status)
 729 {
 730     if (zebra_begin_read (zh))
 731         return;
 732     resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
 733                    output_setname, sort_sequence, sort_status);
 734     zebra_end_read(zh);
 735 }
 736
 737 int zebra_deleleResultSet(ZebraHandle zh, int function,
 738                           int num_setnames, char **setnames,
 739                           int *statuses)
 740 {
 741     int i, status;
 742     if (zebra_begin_read(zh))
 743         return Z_DeleteStatus_systemProblemAtTarget;
 744     switch (function)
 745     {
 746     case Z_DeleteRequest_list:
 747         resultSetDestroy (zh, num_setnames, setnames, statuses);
 748         break;
 749     case Z_DeleteRequest_all:
 750         resultSetDestroy (zh, -1, 0, statuses);
 751         break;
 752     }
 753     zebra_end_read (zh);
 754     status = Z_DeleteStatus_success;
 755     for (i = 0; i<num_setnames; i++)
 756         if (statuses[i] == Z_DeleteStatus_resultSetDidNotExist)
 757             status = statuses[i];
 758     return status;
 759 }
 760
 761 int zebra_errCode (ZebraHandle zh)
 762 {
 763     return zh->errCode;
 764 }
 765
 766 const char *zebra_errString (ZebraHandle zh)
 767 {
 768     return diagbib1_str (zh->errCode);
 769 }
 770
 771 char *zebra_errAdd (ZebraHandle zh)
 772 {
 773     return zh->errString;
 774 }
 775
 776 int zebra_auth (ZebraHandle zh, const char *user, const char *pass)
 777 {
 778     ZebraService zs = zh->service;
 779     if (!zs->passwd_db || !passwd_db_auth (zs->passwd_db, user, pass))
 780     {
 781         logf(LOG_APP,"AUTHOK:%s", user?user:"ANONYMOUS");
 782         return 0;
 783     }
 784
 785     logf(LOG_APP,"AUTHFAIL:%s", user?user:"ANONYMOUS");
 786     return 1;
 787 }
 788
 789 void zebra_admin_import_begin (ZebraHandle zh, const char *database)
 790 {
 791     zebra_begin_trans (zh);
 792     xfree (zh->admin_databaseName);
 793     zh->admin_databaseName = xstrdup(database);
 794 }
 795
 796 void zebra_admin_import_end (ZebraHandle zh)
 797 {
 798     zebra_end_trans (zh);
 799 }
 800
 801 void zebra_admin_import_segment (ZebraHandle zh, Z_Segment *segment)
 802 {
 803     int sysno;
 804     int i;
 805     for (i = 0; i<segment->num_segmentRecords; i++)
 806     {
 807         Z_NamePlusRecord *npr = segment->segmentRecords[i];
 808         const char *databaseName = npr->databaseName;
 809
 810         if (!databaseName)
 811             databaseName = zh->admin_databaseName;
 812         printf ("--------------%d--------------------\n", i);
 813         if (npr->which == Z_NamePlusRecord_intermediateFragment)
 814         {
 815             Z_FragmentSyntax *fragment = npr->u.intermediateFragment;
 816             if (fragment->which == Z_FragmentSyntax_notExternallyTagged)
 817             {
 818                 Odr_oct *oct = fragment->u.notExternallyTagged;
 819                 printf ("%.*s", (oct->len > 100 ? 100 : oct->len) ,
 820                         oct->buf);
 821
 822                 sysno = 0;
 823                 extract_rec_in_mem (zh, "grs.sgml",
 824                                     oct->buf, oct->len,
 825                                     databaseName,
 826                                     0 /* delete_flag */,
 827                                     0 /* test_mode */,
 828                                     &sysno /* sysno */,
 829                                     1 /* store_keys */,
 830                                     1 /* store_data */,
 831                                     0 /* match criteria */);
 832             }
 833         }
 834     }
 835 }
 836
 837 void zebra_admin_create (ZebraHandle zh, const char *database)
 838 {
 839     ZebraService zs;
 840
 841     zebra_begin_trans (zh);
 842
 843     zs = zh->service;
 844     /* announce database */
 845     if (zebraExplain_newDatabase (zh->reg->zei, database, 0
 846                                   /* explainDatabase */))
 847     {
 848         zh->errCode = 224;
 849         zh->errString = "Database already exist";
 850     }
 851     zebra_end_trans (zh);
 852 }
 853
 854 int zebra_string_norm (ZebraHandle zh, unsigned reg_id,
 855                        const char *input_str, int input_len,
 856                        char *output_str, int output_len)
 857 {
 858     WRBUF wrbuf;
 859     if (!zh->reg->zebra_maps)
 860         return -1;
 861     wrbuf = zebra_replace(zh->reg->zebra_maps, reg_id, "",
 862                           input_str, input_len);
 863     if (!wrbuf)
 864         return -2;
 865     if (wrbuf_len(wrbuf) >= output_len)
 866         return -3;
 867     if (wrbuf_len(wrbuf))
 868         memcpy (output_str, wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
 869     output_str[wrbuf_len(wrbuf)] = '\0';
 870     return wrbuf_len(wrbuf);
 871 }
 872
 873
 874 void zebra_set_state (ZebraHandle zh, int val, int seqno)
 875 {
 876     char state_fname[256];
 877     char *fname;
 878     long p = getpid();
 879     FILE *f;
 880
 881     sprintf (state_fname, "state.%s.LCK", zh->reg_name);
 882     fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
 883     f = fopen (fname, "w");
 884
 885     yaz_log (LOG_LOG, "%c %d %ld", val, seqno, p);
 886     fprintf (f, "%c %d %ld\n", val, seqno, p);
 887     fclose (f);
 888     xfree (fname);
 889 }
 890
 891 void zebra_get_state (ZebraHandle zh, char *val, int *seqno)
 892 {
 893     char state_fname[256];
 894     char *fname;
 895     FILE *f;
 896
 897     sprintf (state_fname, "state.%s.LCK", zh->reg_name);
 898     fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
 899     f = fopen (fname, "r");
 900     *val = 'o';
 901     *seqno = 0;
 902
 903     if (f)
 904     {
 905         fscanf (f, "%c %d", val, seqno);
 906         fclose (f);
 907     }
 908     xfree (fname);
 909 }
 910
 911 static int zebra_begin_read (ZebraHandle zh)
 912 {
 913     int dirty = 0;
 914     char val;
 915     int seqno;
 916
 917     assert (zh->res);
 918
 919     (zh->trans_no)++;
 920
 921     if (zh->trans_no != 1)
 922     {
 923         zebra_flush_reg (zh);
 924         return 0;
 925     }
 926     if (!zh->res)
 927     {
 928         (zh->trans_no)--;
 929         zh->errCode = 109;
 930         return -1;
 931     }
 932     zebra_get_state (zh, &val, &seqno);
 933     if (val == 'd')
 934         val = 'o';
 935
 936     if (!zh->reg)
 937         dirty = 1;
 938     else if (seqno != zh->reg->seqno)
 939     {
 940         yaz_log (LOG_LOG, "reopen seqno cur/old %d/%d",
 941                  seqno, zh->reg->seqno);
 942         dirty = 1;
 943     }
 944     else if (zh->reg->last_val != val)
 945     {
 946         yaz_log (LOG_LOG, "reopen last cur/old %d/%d",
 947                  val, zh->reg->last_val);
 948         dirty = 1;
 949     }
 950     if (!dirty)
 951         return 0;
 952
 953     if (val == 'c')
 954         zebra_lock_r (zh->lock_shadow);
 955     else
 956         zebra_lock_r (zh->lock_normal);
 957
 958     if (zh->reg)
 959         zebra_register_close (zh->service, zh->reg);
 960     zh->reg = zebra_register_open (zh->service, zh->reg_name,
 961                                    0, val == 'c' ? 1 : 0,
 962                                    zh->res, zh->path_reg);
 963     if (!zh->reg)
 964     {
 965         zh->errCode = 109;
 966         return -1;
 967     }
 968     zh->reg->last_val = val;
 969     zh->reg->seqno = seqno;
 970
 971     return 0;
 972 }
 973
 974 static void zebra_end_read (ZebraHandle zh)
 975 {
 976     (zh->trans_no)--;
 977
 978     if (zh->trans_no != 0)
 979         return;
 980
 981     zebra_unlock (zh->lock_normal);
 982     zebra_unlock (zh->lock_shadow);
 983 }
 984
 985 void zebra_begin_trans (ZebraHandle zh)
 986 {
 987     int pass;
 988     int seqno = 0;
 989     char val = '?';
 990     const char *rval = 0;
 991
 992     assert (zh->res);
 993
 994     (zh->trans_no++);
 995     if (zh->trans_no != 1)
 996     {
 997         return;
 998     }
 999
1000     yaz_log (LOG_LOG, "zebra_begin_trans");
1001 #if HAVE_SYS_TIMES_H
1002     times (&zh->tms1);
1003 #endif
1004
1005     /* lock */
1006     if (zh->shadow_enable)
1007         rval = res_get (zh->res, "shadow");
1008
1009     for (pass = 0; pass < 2; pass++)
1010     {
1011         if (rval)
1012         {
1013             zebra_lock_r (zh->lock_normal);
1014             zebra_lock_w (zh->lock_shadow);
1015         }
1016         else
1017         {
1018             zebra_lock_w (zh->lock_normal);
1019             zebra_lock_w (zh->lock_shadow);
1020         }
1021
1022         zebra_get_state (zh, &val, &seqno);
1023         if (val == 'c')
1024         {
1025             yaz_log (LOG_LOG, "previous transaction didn't finish commit");
1026             zebra_unlock (zh->lock_shadow);
1027             zebra_unlock (zh->lock_normal);
1028             zebra_commit (zh);
1029             continue;
1030         }
1031         else if (val == 'd')
1032         {
1033             if (rval)
1034             {
1035                 BFiles bfs = bfs_create (res_get (zh->res, "shadow"),
1036                                          zh->path_reg);
1037                 yaz_log (LOG_LOG, "previous transaction didn't reach commit");
1038                 bf_commitClean (bfs, rval);
1039                 bfs_destroy (bfs);
1040             }
1041             else
1042             {
1043                 yaz_log (LOG_WARN, "your previous transaction didn't finish");
1044             }
1045         }
1046         break;
1047     }
1048     if (pass == 2)
1049     {
1050         yaz_log (LOG_FATAL, "zebra_begin_trans couldn't finish commit");
1051         abort();
1052         return;
1053     }
1054     zebra_set_state (zh, 'd', seqno);
1055
1056     zh->reg = zebra_register_open (zh->service, zh->reg_name,
1057                                    1, rval ? 1 : 0, zh->res,
1058                                    zh->path_reg);
1059
1060     zh->reg->seqno = seqno;
1061 }
1062
1063 void zebra_end_trans (ZebraHandle zh)
1064 {
1065     char val;
1066     int seqno;
1067     const char *rval;
1068
1069     zh->trans_no--;
1070     if (zh->trans_no != 0)
1071         return;
1072
1073     yaz_log (LOG_LOG, "zebra_end_trans");
1074     rval = res_get (zh->res, "shadow");
1075
1076     zebra_flush_reg (zh);
1077
1078     zebra_register_close (zh->service, zh->reg);
1079     zh->reg = 0;
1080
1081     zebra_get_state (zh, &val, &seqno);
1082     if (val != 'd')
1083     {
1084         BFiles bfs = bfs_create (rval, zh->path_reg);
1085         yaz_log (LOG_LOG, "deleting shadow stuff val=%c", val);
1086         bf_commitClean (bfs, rval);
1087         bfs_destroy (bfs);
1088     }
1089     if (!rval)
1090         seqno++;
1091     zebra_set_state (zh, 'o', seqno);
1092
1093     zebra_unlock (zh->lock_shadow);
1094     zebra_unlock (zh->lock_normal);
1095
1096 #if HAVE_SYS_TIMES_H
1097     times (&zh->tms2);
1098     logf (LOG_LOG, "user/system: %ld/%ld",
1099                     (long) (zh->tms2.tms_utime - zh->tms1.tms_utime),
1100                     (long) (zh->tms2.tms_stime - zh->tms1.tms_stime));
1101
1102 #endif
1103 }
1104
1105 void zebra_repository_update (ZebraHandle zh)
1106 {
1107     zebra_begin_trans (zh);
1108     logf (LOG_LOG, "updating %s", zh->rGroup.path);
1109     repositoryUpdate (zh);
1110     zebra_end_trans (zh);
1111 }
1112
1113 void zebra_repository_delete (ZebraHandle zh)
1114 {
1115     logf (LOG_LOG, "deleting %s", zh->rGroup.path);
1116     repositoryDelete (zh);
1117 }
1118
1119 void zebra_repository_show (ZebraHandle zh)
1120 {
1121     repositoryShow (zh);
1122 }
1123
1124 int zebra_commit (ZebraHandle zh)
1125 {
1126     int seqno;
1127     char val;
1128     const char *rval;
1129     BFiles bfs;
1130
1131     if (!zh->res)
1132     {
1133         zh->errCode = 109;
1134         return -1;
1135     }
1136     rval = res_get (zh->res, "shadow");
1137     if (!rval)
1138     {
1139         logf (LOG_WARN, "Cannot perform commit");
1140         logf (LOG_WARN, "No shadow area defined");
1141         return 0;
1142     }
1143
1144     zebra_lock_w (zh->lock_normal);
1145     zebra_lock_r (zh->lock_shadow);
1146
1147     bfs = bfs_create (res_get (zh->res, "register"), zh->path_reg);
1148
1149     zebra_get_state (zh, &val, &seqno);
1150
1151     if (rval && *rval)
1152         bf_cache (bfs, rval);
1153     if (bf_commitExists (bfs))
1154     {
1155         zebra_set_state (zh, 'c', seqno);
1156
1157         logf (LOG_LOG, "commit start");
1158 #ifndef WIN32
1159         sleep (2);
1160 #endif
1161         bf_commitExec (bfs);
1162 #ifndef WIN32
1163         sync ();
1164 #endif
1165         logf (LOG_LOG, "commit clean");
1166         bf_commitClean (bfs, rval);
1167         seqno++;
1168         zebra_set_state (zh, 'o', seqno);
1169     }
1170     else
1171     {
1172         logf (LOG_LOG, "nothing to commit");
1173     }
1174     bfs_destroy (bfs);
1175
1176     zebra_unlock (zh->lock_shadow);
1177     zebra_unlock (zh->lock_normal);
1178     return 0;
1179 }
1180
1181 int zebra_init (ZebraHandle zh)
1182 {
1183     const char *rval;
1184     BFiles bfs = 0;
1185
1186     if (!zh->res)
1187     {
1188         zh->errCode = 109;
1189         return -1;
1190     }
1191     rval = res_get (zh->res, "shadow");
1192
1193     bfs = bfs_create (res_get (zh->service->global_res, "register"),
1194                       zh->path_reg);
1195     if (rval && *rval)
1196         bf_cache (bfs, rval);
1197
1198     bf_reset (bfs);
1199     bfs_destroy (bfs);
1200     zebra_set_state (zh, 'o', 0);
1201     return 0;
1202 }
1203
1204 int zebra_compact (ZebraHandle zh)
1205 {
1206     BFiles bfs;
1207     if (!zh->res)
1208     {
1209         zh->errCode = 109;
1210         return -1;
1211     }
1212     bfs = bfs_create (res_get (zh->res, "register"), zh->path_reg);
1213     inv_compact (bfs);
1214     bfs_destroy (bfs);
1215     return 0;
1216 }
1217
1218 int zebra_record_insert (ZebraHandle zh, const char *buf, int len)
1219 {
1220     int sysno = 0;
1221     zebra_begin_trans (zh);
1222     extract_rec_in_mem (zh, "grs.sgml",
1223                         buf, len,
1224                         "Default",  /* database */
1225                         0 /* delete_flag */,
1226                         0 /* test_mode */,
1227                         &sysno /* sysno */,
1228                         1 /* store_keys */,
1229                         1 /* store_data */,
1230                         0 /* match criteria */);
1231     zebra_end_trans (zh);
1232     return sysno;
1233 }
1234
1235 void zebra_set_group (ZebraHandle zh, struct recordGroup *rg)
1236 {
1237     memcpy (&zh->rGroup, rg, sizeof(*rg));
1238 }
1239
1240 void zebra_result (ZebraHandle zh, int *code, char **addinfo)
1241 {
1242     *code = zh->errCode;
1243     *addinfo = zh->errString;
1244 }
1245
1246 void zebra_shadow_enable (ZebraHandle zh, int value)
1247 {
1248     zh->shadow_enable = value;
1249 }
1250