X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Flockidx.c;h=cd2583fd470ee96e7d24bb445e0d4d7e90b799c6;hb=28f3461a79a4569d736f4ffc66c6ae207e38c2ab;hp=10be062fc09b5fbbe4db97791d37a9ff1e626f47;hpb=b9093505b17a074e79137ed64595c8269f77d330;p=idzebra-moved-to-github.git diff --git a/index/lockidx.c b/index/lockidx.c index 10be062..cd2583f 100644 --- a/index/lockidx.c +++ b/index/lockidx.c @@ -1,10 +1,25 @@ /* - * Copyright (C) 1994-1995, Index Data I/S + * Copyright (C) 1994-1999, Index Data * All rights reserved. * Sebastian Hammer, Adam Dickmeiss * * $Log: lockidx.c,v $ - * Revision 1.11 1997-09-17 12:19:15 adam + * Revision 1.16 1999-02-02 14:50:57 adam + * Updated WIN32 code specific sections. Changed header. + * + * Revision 1.15 1998/02/17 10:31:33 adam + * Fixed bug in zebraIndexUnlock. On NT, the lock files wasn't removed. + * + * Revision 1.14 1998/01/12 15:04:08 adam + * The test option (-s) only uses read-lock (and not write lock). + * + * Revision 1.13 1997/09/29 09:08:36 adam + * Revised locking system to be thread safe for the server. + * + * Revision 1.12 1997/09/25 14:54:43 adam + * WIN32 files lock support. + * + * Revision 1.11 1997/09/17 12:19:15 adam * Zebra version corresponds to YAZ version 1.4. * Changed Zebra server so that it doesn't depend on global common_resource. * @@ -49,7 +64,7 @@ */ #include #include -#ifdef WINDOWS +#ifdef WIN32 #include #else #include @@ -60,66 +75,68 @@ #include "index.h" -static int lock_fd = -1; -static int server_lock_cmt = -1; -static int server_lock_org = -1; +static ZebraLockHandle server_lock_main = NULL; +static ZebraLockHandle server_lock_cmt = NULL; +static ZebraLockHandle server_lock_org = NULL; int zebraIndexWait (int commitPhase) { - char pathPrefix[1024]; - char path[1024]; - int fd; - - zebraLockPrefix (common_resource, pathPrefix); + ZebraLockHandle h; - if (server_lock_cmt == -1) + if (server_lock_cmt) + zebra_unlock (server_lock_cmt); + else { - sprintf (path, "%s%s", pathPrefix, FNAME_COMMIT_LOCK); - if ((server_lock_cmt = open (path, O_BINARY|O_CREAT|O_RDWR|O_SYNC, - 0666)) - == -1) - { - logf (LOG_FATAL|LOG_ERRNO, "create %s", path); - return -1; - } + char path[1024]; + + zebra_lock_prefix (common_resource, path); + strcat (path, FNAME_COMMIT_LOCK); + server_lock_cmt = zebra_lock_create (path, 1); + if (!server_lock_cmt) + { + logf (LOG_WARN|LOG_ERRNO, "cannot create lock %s", path); + return -1; + } } + if (server_lock_org) + zebra_unlock (server_lock_org); else - zebraUnlock (server_lock_cmt); - if (server_lock_org == -1) { - sprintf (path, "%s%s", pathPrefix, FNAME_ORG_LOCK); - if ((server_lock_org = open (path, O_BINARY|O_CREAT|O_RDWR|O_SYNC, - 0666)) - == -1) - { - logf (LOG_FATAL|LOG_ERRNO, "create %s", path); - return -1; - } + char path[1024]; + + zebra_lock_prefix (common_resource, path); + strcat (path, FNAME_ORG_LOCK); + server_lock_org = zebra_lock_create (path, 1); + if (!server_lock_org) + { + logf (LOG_WARN|LOG_ERRNO, "cannot create lock %s", path); + return -1; + } } - else - zebraUnlock (server_lock_org); if (commitPhase) - fd = server_lock_cmt; + h = server_lock_cmt; else - fd = server_lock_org; - if (zebraLockNB (fd, 1) == -1) + h = server_lock_org; + if (zebra_lock_nb (h)) { +#ifndef WIN32 if (errno != EWOULDBLOCK) { logf (LOG_FATAL|LOG_ERRNO, "flock"); exit (1); } +#endif if (commitPhase) logf (LOG_LOG, "Waiting for lock cmt"); else logf (LOG_LOG, "Waiting for lock org"); - if (zebraLock (fd, 1) == -1) + if (zebra_lock (h) == -1) { - logf (LOG_FATAL|LOG_ERRNO, "flock"); + logf (LOG_FATAL, "flock"); exit (1); } } - zebraUnlock (fd); + zebra_unlock (h); return 0; } @@ -127,20 +144,20 @@ int zebraIndexWait (int commitPhase) void zebraIndexLockMsg (const char *str) { char path[1024]; - char pathPrefix[1024]; int l, r, fd; - assert (lock_fd != -1); - lseek (lock_fd, 0L, SEEK_SET); + assert (server_lock_main); + fd = zebra_lock_fd (server_lock_main); + lseek (fd, 0L, SEEK_SET); l = strlen(str); - r = write (lock_fd, str, l); + r = write (fd, str, l); if (r != l) { logf (LOG_FATAL|LOG_ERRNO, "write lock file"); exit (1); } - zebraLockPrefix (common_resource, pathPrefix); - sprintf (path, "%s%s", pathPrefix, FNAME_TOUCH_TIME); + zebra_lock_prefix (common_resource, path); + strcat (path, FNAME_TOUCH_TIME); fd = creat (path, 0666); close (fd); } @@ -148,45 +165,53 @@ void zebraIndexLockMsg (const char *str) void zebraIndexUnlock (void) { char path[1024]; - char pathPrefix[1024]; - - zebraLockPrefix (common_resource, pathPrefix); - sprintf (path, "%s%s", pathPrefix, FNAME_MAIN_LOCK); - unlink (path); + + zebra_lock_destroy (server_lock_main); + zebra_lock_prefix (common_resource, path); + strcat (path, FNAME_MAIN_LOCK); + if (unlink (path)) + logf (LOG_WARN|LOG_ERRNO, "unlink %s", path); } void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) { char path[1024]; - char pathPrefix[1024]; char buf[256]; int r; - if (lock_fd != -1) + if (server_lock_main) return ; - zebraLockPrefix (common_resource, pathPrefix); - sprintf (path, "%s%s", pathPrefix, FNAME_MAIN_LOCK); + + zebra_lock_prefix (common_resource, path); + strcat (path, FNAME_MAIN_LOCK); while (1) { - lock_fd = open (path, O_BINARY|O_CREAT|O_RDWR|O_EXCL, 0666); - if (lock_fd == -1) + server_lock_main = zebra_lock_create (path, 2); + if (!server_lock_main) { - lock_fd = open (path, O_BINARY|O_RDWR); - if (lock_fd == -1) + server_lock_main = zebra_lock_create (path, 1); + if (!server_lock_main) { if (errno == ENOENT) continue; logf (LOG_FATAL|LOG_ERRNO, "open %s", path); exit (1); } - if (zebraLockNB (lock_fd, 1) == -1) + if (zebra_lock_nb (server_lock_main) == -1) { +#ifdef WIN32 + logf (LOG_LOG, "waiting for other index process"); + zebra_lock (server_lock_main); + zebra_unlock (server_lock_main); + zebra_lock_destroy (server_lock_main); + continue; +#else if (errno == EWOULDBLOCK) { logf (LOG_LOG, "waiting for other index process"); - zebraLock (lock_fd, 1); - zebraUnlock (lock_fd); - close (lock_fd); + zebra_lock (server_lock_main); + zebra_unlock (server_lock_main); + zebra_lock_destroy (server_lock_main); continue; } else @@ -194,16 +219,19 @@ void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) logf (LOG_FATAL|LOG_ERRNO, "flock %s", path); exit (1); } +#endif } else { + int fd = zebra_lock_fd (server_lock_main); + logf (LOG_WARN, "unlocked %s", path); - r = read (lock_fd, buf, 256); + r = read (fd, buf, 256); if (r == 0) { logf (LOG_WARN, "zero length %s", path); - close (lock_fd); - unlink (path); + zebra_lock_destroy (server_lock_main); + unlink (path); continue; } else if (r == -1) @@ -215,7 +243,7 @@ void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) { logf (LOG_WARN, "previous transaction didn't" " reach commit"); - close (lock_fd); + zebra_lock_destroy (server_lock_main); bf_commitClean (bfs, rval); unlink (path); continue; @@ -223,14 +251,19 @@ void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) else if (*buf == 'd') { logf (LOG_WARN, "commit file wan't deleted after commit"); - close (lock_fd); + zebra_lock_destroy (server_lock_main); bf_commitClean (bfs, rval); unlink (path); continue; } else if (*buf == 'w') { - logf (LOG_WARN, "your index may be inconsistent"); + logf (LOG_WARN, + "The lock file indicates that your index is"); + logf (LOG_WARN, "inconsistent. Perhaps the indexer"); + logf (LOG_WARN, "terminated abnormally in the previous"); + logf (LOG_WARN, "run. You can try to proceed by"); + logf (LOG_WARN, "deleting the file %s", path); exit (1); } else if (*buf == 'c') @@ -238,7 +271,7 @@ void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) if (commitNow) { unlink (path); - close (lock_fd); + zebra_lock_destroy (server_lock_main); continue; } logf (LOG_FATAL, "previous transaction didn't" @@ -256,6 +289,6 @@ void zebraIndexLock (BFiles bfs, int commitNow, const char *rval) else break; } - zebraLock (lock_fd, 1); + zebra_lock (server_lock_main); }