*** empty log message ***
[idzebra-moved-to-github.git] / index / lockidx.c
1 /*
2  * Copyright (C) 1994-1999, Index Data
3  * All rights reserved.
4  * Sebastian Hammer, Adam Dickmeiss
5  *
6  * $Log: lockidx.c,v $
7  * Revision 1.21  2002-02-20 17:30:01  adam
8  * Work on new API. Locking system re-implemented
9  *
10  * Revision 1.20  2000/10/16 20:16:00  adam
11  * Fixed problem with close of lock file for WIN32.
12  *
13  * Revision 1.19  2000/09/05 14:04:05  adam
14  * Updates for prefix 'yaz_' for YAZ log functions.
15  *
16  * Revision 1.18  2000/02/24 11:00:07  adam
17  * Fixed bug: indexer would run forever when lock dir was non-existant.
18  *
19  * Revision 1.17  1999/12/08 15:03:11  adam
20  * Implemented bf_reset.
21  *
22  * Revision 1.16  1999/02/02 14:50:57  adam
23  * Updated WIN32 code specific sections. Changed header.
24  *
25  * Revision 1.15  1998/02/17 10:31:33  adam
26  * Fixed bug in zebraIndexUnlock. On NT, the lock files wasn't removed.
27  *
28  * Revision 1.14  1998/01/12 15:04:08  adam
29  * The test option (-s) only uses read-lock (and not write lock).
30  *
31  * Revision 1.13  1997/09/29 09:08:36  adam
32  * Revised locking system to be thread safe for the server.
33  *
34  * Revision 1.12  1997/09/25 14:54:43  adam
35  * WIN32 files lock support.
36  *
37  * Revision 1.11  1997/09/17 12:19:15  adam
38  * Zebra version corresponds to YAZ version 1.4.
39  * Changed Zebra server so that it doesn't depend on global common_resource.
40  *
41  * Revision 1.10  1997/09/09 13:38:07  adam
42  * Partial port to WIN95/NT.
43  *
44  * Revision 1.9  1997/09/04 13:58:04  adam
45  * Added O_BINARY for open calls.
46  *
47  * Revision 1.8  1997/02/12 20:39:46  adam
48  * Implemented options -f <n> that limits the log to the first <n>
49  * records.
50  * Changed some log messages also.
51  *
52  * Revision 1.7  1996/10/29 14:08:13  adam
53  * Uses resource lockDir instead of lockPath.
54  *
55  * Revision 1.6  1996/03/26 16:01:13  adam
56  * New setting lockPath: directory of various lock files.
57  *
58  * Revision 1.5  1995/12/13  08:46:09  adam
59  * Locking uses F_WRLCK and F_RDLCK again!
60  *
61  * Revision 1.4  1995/12/12  16:00:57  adam
62  * System call sync(2) used after update/commit.
63  * Locking (based on fcntl) uses F_EXLCK and F_SHLCK instead of F_WRLCK
64  * and F_RDLCK.
65  *
66  * Revision 1.3  1995/12/11  11:43:29  adam
67  * Locking based on fcntl instead of flock.
68  * Setting commitEnable removed. Command line option -n can be used to
69  * prevent commit if commit setting is defined in the configuration file.
70  *
71  * Revision 1.2  1995/12/08  16:22:54  adam
72  * Work on update while servers are running. Three lock files introduced.
73  * The servers reload their registers when necessary, but they don't
74  * reestablish result sets yet.
75  *
76  * Revision 1.1  1995/12/07  17:38:47  adam
77  * Work locking mechanisms for concurrent updates/commit.
78  *
79  */
80 #include <stdio.h>
81 #include <assert.h>
82 #ifdef WIN32
83 #include <io.h>
84 #else
85 #include <unistd.h>
86 #endif
87 #include <fcntl.h>
88 #include <string.h>
89 #include <errno.h>
90
91 #include "index.h"
92 #include "zserver.h"
93
94 static ZebraLockHandle server_lock_main = NULL;
95 static ZebraLockHandle server_lock_cmt = NULL;
96 static ZebraLockHandle server_lock_org = NULL;
97
98 int zebraIndexWait (ZebraHandle zh, int commitPhase)
99 {
100     ZebraLockHandle h;
101
102     if (server_lock_cmt)
103         zebra_unlock (server_lock_cmt);
104     else
105     {
106         char path[1024];
107
108         zebra_lock_prefix (zh->service->res, path);
109         strcat (path, FNAME_COMMIT_LOCK);
110         server_lock_cmt = zebra_lock_create (path, 1);
111         if (!server_lock_cmt)
112         {
113             logf (LOG_WARN|LOG_ERRNO, "cannot create lock %s", path);
114             return -1;
115         }
116     }
117     if (server_lock_org)
118         zebra_unlock (server_lock_org);
119     else
120     {
121         char path[1024];
122
123         zebra_lock_prefix (zh->service->res, path);
124         strcat (path, FNAME_ORG_LOCK);
125         server_lock_org = zebra_lock_create (path, 1);
126         if (!server_lock_org)
127         {
128             logf (LOG_WARN|LOG_ERRNO, "cannot create lock %s", path);
129             return -1;
130         }
131     }
132     if (commitPhase)
133         h = server_lock_cmt;
134     else
135         h = server_lock_org;
136     if (zebra_lock_nb (h))
137     {
138 #ifndef WIN32
139         if (errno != EWOULDBLOCK)
140         {
141             logf (LOG_FATAL|LOG_ERRNO, "flock");
142             exit (1);
143         }
144 #endif
145         if (commitPhase)
146             logf (LOG_LOG, "Waiting for lock cmt");
147         else
148             logf (LOG_LOG, "Waiting for lock org");
149         if (zebra_lock (h) == -1)
150         {
151             logf (LOG_FATAL, "flock");
152             exit (1);
153         }
154     }
155     zebra_unlock (h);
156     return 0;
157 }
158
159
160 void zebraIndexLockMsg (ZebraHandle zh, const char *str)
161 {
162     char path[1024];
163     int l, r, fd;
164
165     assert (server_lock_main);
166     fd = zebra_lock_fd (server_lock_main);
167     lseek (fd, 0L, SEEK_SET);
168     l = strlen(str);
169     r = write (fd, str, l);
170     if (r != l)
171     {
172         logf (LOG_FATAL|LOG_ERRNO, "write lock file");
173         exit (1);
174     }
175     zebra_lock_prefix (zh->service->res, path);
176     strcat (path, FNAME_TOUCH_TIME);
177     fd = creat (path, 0666);
178     close (fd);
179 }
180
181 void zebraIndexUnlock (ZebraHandle zh)
182 {
183     char path[1024];
184     
185     zebra_lock_prefix (zh->service->res, path);
186     strcat (path, FNAME_MAIN_LOCK);
187 #ifdef WIN32
188     zebra_lock_destroy (server_lock_main);
189     if (unlink (path) && errno != ENOENT)
190         logf (LOG_WARN|LOG_ERRNO, "unlink %s failed", path);
191 #else
192     if (unlink (path) && errno != ENOENT)
193         logf (LOG_WARN|LOG_ERRNO, "unlink %s failed", path);
194     zebra_lock_destroy (server_lock_main);
195 #endif
196     server_lock_main = 0;
197 }
198
199 int zebraIndexLock (BFiles bfs, ZebraHandle zh, int commitNow,
200                     const char *rval)
201 {
202     char path[1024];
203     char buf[256];
204     int r;
205
206     if (server_lock_main)
207         return 0;
208
209     zebra_lock_prefix (zh->service->res, path);
210     strcat (path, FNAME_MAIN_LOCK);
211     while (1)
212     {
213         server_lock_main = zebra_lock_create (path, 2);
214         if (!server_lock_main)
215         {
216             server_lock_main = zebra_lock_create (path, 1);
217             if (!server_lock_main)
218             {
219                 logf (LOG_FATAL, "couldn't obtain indexer lock");
220                 exit (1);
221             }
222             if (zebra_lock_nb (server_lock_main) == -1)
223             {
224 #ifdef WIN32
225                 logf (LOG_LOG, "waiting for other index process");
226                 zebra_lock (server_lock_main);
227                 zebra_unlock (server_lock_main);
228                 zebra_lock_destroy (server_lock_main);
229                 continue;
230 #else
231                 if (errno == EWOULDBLOCK)
232                 {
233                     logf (LOG_LOG, "waiting for other index process");
234                     zebra_lock (server_lock_main);
235                     zebra_unlock (server_lock_main);
236                     zebra_lock_destroy (server_lock_main);
237                     continue;
238                 }
239                 else
240                 {
241                     logf (LOG_FATAL|LOG_ERRNO, "flock %s", path);
242                     exit (1);
243                 }
244 #endif
245             }
246             else
247             {
248                 int fd = zebra_lock_fd (server_lock_main);
249
250                 logf (LOG_WARN, "unlocked %s", path);
251                 r = read (fd, buf, 256);
252                 if (r == 0)
253                 {
254                     logf (LOG_WARN, "zero length %s", path);
255                     zebra_lock_destroy (server_lock_main);
256                     unlink (path);
257                     continue;
258                 }
259                 else if (r == -1)
260                 {
261                     logf (LOG_FATAL|LOG_ERRNO, "read %s", path);
262                     exit (1);
263                 }
264                 if (*buf == 'r')
265                 {
266                     logf (LOG_WARN, "previous transaction didn't"
267                           " reach commit");
268                     zebra_lock_destroy (server_lock_main);
269                     bf_commitClean (bfs, rval);
270                     unlink (path);
271                     continue;
272                 }
273                 else if (*buf == 'd')
274                 {
275                     logf (LOG_WARN, "commit file wan't deleted after commit");
276                     zebra_lock_destroy (server_lock_main);
277                     bf_commitClean (bfs, rval);
278                     unlink (path);
279                     continue;
280                 }                    
281                 else if (*buf == 'w')
282                 {
283                     logf (LOG_WARN,
284                           "The lock file indicates that your index is");
285                     logf (LOG_WARN, "inconsistent. Perhaps the indexer");
286                     logf (LOG_WARN, "terminated abnormally in the previous");
287                     logf (LOG_WARN, "run. You can try to proceed by");
288                     logf (LOG_WARN, "deleting the file %s", path);
289                     exit (1);
290                 }
291                 else if (*buf == 'c')
292                 {
293                     if (commitNow)
294                     {
295                         unlink (path);
296                         zebra_lock_destroy (server_lock_main);
297                         continue;
298                     }
299                     logf (LOG_FATAL, "previous transaction didn't"
300                           " finish commit. Commit now!");
301                     exit (1);
302                 }
303                 else 
304                 {
305                     logf (LOG_FATAL, "unknown id 0x%02x in %s", *buf,
306                           path);
307                     exit (1);
308                 }
309             }
310         }
311         else
312             break;
313     }
314     zebra_lock (server_lock_main);
315     return 0;
316 }
317