index/locksrv.c

   1 /*
   2  * Copyright (C) 1994-1997, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: locksrv.c,v $
   7  * Revision 1.10  1997-09-29 09:08:36  adam
   8  * Revised locking system to be thread safe for the server.
   9  *
  10  * Revision 1.9  1997/09/25 14:54:43  adam
  11  * WIN32 files lock support.
  12  *
  13  * Revision 1.8  1997/09/17 12:19:15  adam
  14  * Zebra version corresponds to YAZ version 1.4.
  15  * Changed Zebra server so that it doesn't depend on global common_resource.
  16  *
  17  * Revision 1.7  1997/09/04 13:58:04  adam
  18  * Added O_BINARY for open calls.
  19  *
  20  * Revision 1.6  1996/10/29 14:06:52  adam
  21  * Include zebrautl.h instead of alexutil.h.
  22  *
  23  * Revision 1.5  1996/05/15 11:58:18  adam
  24  * Changed some log messages.
  25  *
  26  * Revision 1.4  1996/04/10  16:01:27  quinn
  27  * Fixed order of path/filename.
  28  *
  29  * Revision 1.3  1995/12/11  11:43:29  adam
  30  * Locking based on fcntl instead of flock.
  31  * Setting commitEnable removed. Command line option -n can be used to
  32  * prevent commit if commit setting is defined in the configuration file.
  33  *
  34  * Revision 1.2  1995/12/08  16:22:55  adam
  35  * Work on update while servers are running. Three lock files introduced.
  36  * The servers reload their registers when necessary, but they don't
  37  * reestablish result sets yet.
  38  *
  39  * Revision 1.1  1995/12/07  17:38:47  adam
  40  * Work locking mechanisms for concurrent updates/commit.
  41  *
  42  */
  43 #include <stdio.h>
  44 #include <assert.h>
  45 #ifdef WINDOWS
  46 #include <io.h>
  47 #else
  48 #include <unistd.h>
  49 #endif
  50 #include <sys/stat.h>
  51 #include <fcntl.h>
  52 #include <string.h>
  53 #include <errno.h>
  54
  55 #include "zserver.h"
  56
  57 int zebra_server_lock_init (ZServerInfo *zi)
  58 {
  59     char path_prefix[1024];
  60
  61     assert (zi->res);
  62     zi->server_lock_cmt = NULL;
  63     zi->server_lock_org = NULL;
  64
  65     zebra_lock_prefix (zi->res, path_prefix);
  66     zi->server_path_prefix = xmalloc (strlen(path_prefix)+1);
  67     strcpy (zi->server_path_prefix, path_prefix);
  68
  69     logf (LOG_DEBUG, "Locking system initialized");
  70     return 0;
  71 }
  72
  73 int zebra_server_lock_destroy (ZServerInfo *zi)
  74 {
  75     xfree (zi->server_path_prefix);
  76     zebra_lock_destroy (zi->server_lock_cmt);
  77     zebra_lock_destroy (zi->server_lock_org);
  78     logf (LOG_DEBUG, "Locking system destroyed");
  79     return 0;
  80 }
  81
  82 int zebra_server_lock (ZServerInfo *zi, int commitPhase)
  83 {
  84     if (!zi->server_lock_cmt)
  85     {
  86         char path[1024];
  87
  88         strcpy (path, zi->server_path_prefix);
  89         strcat (path, FNAME_COMMIT_LOCK);
  90         if (!(zi->server_lock_cmt = zebra_lock_create (path, 0)))
  91         {
  92             logf (LOG_FATAL|LOG_ERRNO, "create %s", path);
  93             return -1;
  94         }
  95         assert (zi->server_lock_org == NULL);
  96
  97         strcpy (path, zi->server_path_prefix);
  98         strcat (path, FNAME_ORG_LOCK);
  99         if (!(zi->server_lock_org = zebra_lock_create (path, 0)))
 100         {
 101             logf (LOG_FATAL|LOG_ERRNO, "create %s", path);
 102             return -1;
 103         }
 104     }
 105     if (commitPhase)
 106     {
 107         logf (LOG_DEBUG, "Server locks org");
 108         zebra_lock (zi->server_lock_org);
 109     }
 110     else
 111     {
 112         logf (LOG_DEBUG, "Server locks cmt");
 113         zebra_lock (zi->server_lock_cmt);
 114     }
 115     return 0;
 116 }
 117
 118 void zebra_server_unlock (ZServerInfo *zi, int commitPhase)
 119 {
 120     if (zi->server_lock_org == NULL)
 121         return;
 122     if (commitPhase)
 123     {
 124         logf (LOG_DEBUG, "Server unlocks org");
 125         zebra_unlock (zi->server_lock_org);
 126     }
 127     else
 128     {
 129         logf (LOG_DEBUG, "Server unlocks cmt");
 130         zebra_unlock (zi->server_lock_cmt);
 131     }
 132 }
 133
 134 int zebra_server_lock_get_state (ZServerInfo *zi, time_t *timep)
 135 {
 136     char path[1024];
 137     char buf[256];
 138     int fd;
 139     struct stat xstat;
 140
 141     strcpy (path, zi->server_path_prefix);
 142     strcat (path, FNAME_TOUCH_TIME);
 143     if (stat (path, &xstat) == -1)
 144         *timep = 1;
 145     else
 146         *timep = xstat.st_ctime;
 147
 148     strcpy (path, zi->server_path_prefix);
 149     strcat (path, FNAME_MAIN_LOCK);
 150     fd = open (path, O_BINARY|O_RDONLY);
 151     if (fd == -1)
 152     {
 153         *buf = 0;
 154         return 0;
 155     }
 156     if (read (fd, buf, 2) == 0)
 157     {
 158         *buf = 0;
 159         return 0;
 160     }
 161     close (fd);
 162     return *buf;
 163 }