beagled/Lucene.Net/Store/Lock.cs

   1 /*
   2  * Copyright 2004 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using IndexWriter = Lucene.Net.Index.IndexWriter;
  19
  20 namespace Lucene.Net.Store
  21 {
  22
  23         /// <summary>An interprocess mutex lock.
  24         /// <p>Typical use might look like:<pre>
  25         /// new Lock.With(directory.makeLock("my.lock")) {
  26         /// public Object doBody() {
  27         /// <i>... code to execute while locked ...</i>
  28         /// }
  29         /// }.Run();
  30         /// </pre>
  31         ///
  32         /// </summary>
  33         /// <author>  Doug Cutting
  34         /// </author>
  35         /// <version>  $Id: Lock.cs,v 1.8 2006/10/02 17:11:11 joeshaw Exp $
  36         /// </version>
  37         /// <seealso cref="Directory.MakeLock(String)">
  38         /// </seealso>
  39         public abstract class Lock
  40         {
  41                 public static long LOCK_POLL_INTERVAL = 1000;
  42
  43                 /// <summary>Attempts to obtain exclusive access and immediately return
  44                 /// upon success or failure.
  45                 /// </summary>
  46                 /// <returns> true iff exclusive access is obtained
  47                 /// </returns>
  48                 public abstract bool Obtain();
  49
  50                 /// <summary>Attempts to obtain an exclusive lock within amount
  51                 /// of time given. Currently polls once per second until
  52                 /// lockWaitTimeout is passed.
  53                 /// </summary>
  54                 /// <param name="lockWaitTimeout">length of time to wait in ms
  55                 /// </param>
  56                 /// <returns> true if lock was obtained
  57                 /// </returns>
  58                 /// <throws>  IOException if lock wait times out or obtain() throws an IOException </throws>
  59                 public virtual bool Obtain(long lockWaitTimeout)
  60                 {
  61                         int sleepCount = 0;
  62                         bool locked = Obtain();
  63                         int maxSleepCount = (int) (lockWaitTimeout / LOCK_POLL_INTERVAL);
  64                         maxSleepCount = System.Math.Min (maxSleepCount, 1);
  65
  66                         while (!locked)
  67                         {
  68                                 FSDirectory.Log ("Lock.Obtain timeout: sleepcount = {0} (timeout={1},maxsleepcount={2})", sleepCount, lockWaitTimeout, maxSleepCount);
  69                                 if (sleepCount++ == maxSleepCount)
  70                                 {
  71                                         // Try and be a little more verbose on failure
  72                                         string lockpath = this.ToString ();
  73                                         System.Text.StringBuilder ex = new System.Text.StringBuilder();
  74                                         ex.Append ("Lock obain timed out: ");
  75                                         ex.Append (lockpath);
  76                                         if (System.IO.File.Exists (lockpath)) {
  77                                                 System.IO.FileStream fs = System.IO.File.Open (lockpath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read);
  78                                                 System.IO.StreamReader sr = new System.IO.StreamReader (fs);
  79                                                 string pid = sr.ReadToEnd ().Trim ();
  80                                                 sr.Close ();
  81                                                 fs.Close ();
  82                                                 ex.Append (" -- pid ").Append (pid);
  83
  84                                                 if (System.IO.Directory.Exists ("/proc/" + pid))
  85                                                         ex.Append (" -- process exists");
  86                                                 else
  87                                                         ex.Append (" -- process does not exist, stale lockfile?");
  88                                         } else {
  89                                                 ex.Append (" -- lock file doesn't exist!?");
  90                                         }
  91                                         throw new System.IO.IOException(ex.ToString ());
  92                                 }
  93                                 System.Threading.Thread.Sleep((int) LOCK_POLL_INTERVAL);
  94                                 locked = Obtain();
  95                         }
  96                         return locked;
  97                 }
  98
  99                 /// <summary>Releases exclusive access. </summary>
 100                 public abstract void  Release();
 101
 102                 /// <summary>Returns true if the resource is currently locked.  Note that one must
 103                 /// still call {@link #Obtain()} before using the resource.
 104                 /// </summary>
 105                 public abstract bool IsLocked();
 106
 107
 108                 /// <summary>Utility class for executing code with exclusive access. </summary>
 109                 public abstract class With
 110                 {
 111                         private Lock lock_Renamed;
 112                         private long lockWaitTimeout;
 113
 114                         /// <summary>Constructs an executor that will grab the named lock.
 115                         /// Defaults lockWaitTimeout to Lock.COMMIT_LOCK_TIMEOUT.
 116                         /// </summary>
 117                         /// <deprecated> Kept only to avoid breaking existing code.
 118                         /// </deprecated>
 119                         public With(Lock lock_Renamed) : this(lock_Renamed, IndexWriter.COMMIT_LOCK_TIMEOUT)
 120                         {
 121                         }
 122
 123                         /// <summary>Constructs an executor that will grab the named lock. </summary>
 124                         public With(Lock lock_Renamed, long lockWaitTimeout)
 125                         {
 126                                 this.lock_Renamed = lock_Renamed;
 127                                 this.lockWaitTimeout = lockWaitTimeout;
 128                         }
 129
 130                         /// <summary>Code to execute with exclusive access. </summary>
 131                         public abstract System.Object DoBody();
 132
 133                         /// <summary>Calls {@link #doBody} while <i>lock</i> is obtained.  Blocks if lock
 134                         /// cannot be obtained immediately.  Retries to obtain lock once per second
 135                         /// until it is obtained, or until it has tried ten times. Lock is released when
 136                         /// {@link #doBody} exits.
 137                         /// </summary>
 138                         public virtual System.Object Run()
 139                         {
 140                                 bool locked = false;
 141                                 try
 142                                 {
 143                                         locked = lock_Renamed.Obtain(lockWaitTimeout);
 144                                         return DoBody();
 145                                 }
 146                                 finally
 147                                 {
 148                                         if (locked)
 149                                                 lock_Renamed.Release();
 150                                 }
 151                         }
 152                 }
 153         }
 154 }