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