beagled/Lucene.Net/Store/FSDirectory.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 using System;
  17 using Constants = Lucene.Net.Util.Constants;
  18 using System.Diagnostics; // FIXED joeshaw@novell.com 10 Jan 2005 - for lock debugging
  19 namespace Lucene.Net.Store
  20 {
  21
  22         /// <summary> Straightforward implementation of {@link Directory} as a directory of files.
  23         /// <p>If the system property 'disableLuceneLocks' has the String value of
  24         /// "true", lock creation will be disabled.
  25         ///
  26         /// </summary>
  27         /// <seealso cref="Directory">
  28         /// </seealso>
  29         /// <author>  Doug Cutting
  30         /// </author>
  31         public sealed class FSDirectory : Directory
  32         {
  33                 private class AnonymousClassLock : Lock
  34                 {
  35                         public AnonymousClassLock(System.IO.FileInfo lockFile, FSDirectory enclosingInstance)
  36                         {
  37                                 InitBlock(lockFile, enclosingInstance);
  38                         }
  39                         private void  InitBlock(System.IO.FileInfo lockFile, FSDirectory enclosingInstance)
  40                         {
  41                                 this.lockFile = lockFile;
  42                                 this.enclosingInstance = enclosingInstance;
  43                         }
  44                         private System.IO.FileInfo lockFile;
  45                         private FSDirectory enclosingInstance;
  46                         public FSDirectory Enclosing_Instance
  47                         {
  48                                 get
  49                                 {
  50                                         return enclosingInstance;
  51                                 }
  52
  53                         }
  54                         public override bool Obtain()
  55                         {
  56                                 if (Lucene.Net.Store.FSDirectory.DISABLE_LOCKS)
  57                                         return true;
  58
  59                                 // ADDED fhedberg@novell.com 16 Jun 2005
  60                                 if (Enclosing_Instance.DisableLocks)
  61                                         return true;
  62
  63                                 bool tmpBool;
  64                                 if (System.IO.File.Exists(Enclosing_Instance.lockDir.FullName))
  65                                         tmpBool = true;
  66                                 else
  67                                         tmpBool = System.IO.Directory.Exists(Enclosing_Instance.lockDir.FullName);
  68                                 if (!tmpBool)
  69                                 {
  70                                         try
  71                                         {
  72                                                 System.IO.Directory.CreateDirectory(Enclosing_Instance.lockDir.FullName);
  73                                         }
  74                                         catch (Exception)
  75                                         {
  76                                                 throw new System.IO.IOException("Cannot create lock directory: " + Enclosing_Instance.lockDir);
  77                                         }
  78                                 }
  79
  80                                 // ADDED trow@novell.com 17 Mar 2005: Use Mono.Posix for lock creation
  81
  82                                 bool obtainedLock = false;
  83
  84                                 int fd = Mono.Posix.Syscall.open (lockFile.FullName,
  85                                                                   Mono.Posix.OpenFlags.O_CREAT
  86                                                                   | Mono.Posix.OpenFlags.O_EXCL,
  87                                                                   Mono.Posix.FileMode.S_IRUSR
  88                                                                   | Mono.Posix.FileMode.S_IWUSR);
  89
  90                                 if (fd != -1) {
  91                                         Mono.Posix.Syscall.close (fd);
  92                                         lockFile.Refresh ();
  93                                         obtainedLock = true;
  94                                 }
  95
  96
  97 #if false
  98                                 try
  99                                 {
 100                                         System.IO.FileStream createdFile = lockFile.Create();
 101                                         createdFile.Close();
 102                                         obtainedLock = true;
 103                                 }
 104                                 catch (Exception e)
 105                                 {
 106                                         // Just fall through
 107                                 }
 108 #endif
 109
 110                                 Log ("{0} lock {1}", obtainedLock ? "Obtained" : "Could not obtain", lockFile.FullName);
 111                                 return obtainedLock;
 112                         }
 113
 114                         public override void  Release()
 115                         {
 116                                 if (Lucene.Net.Store.FSDirectory.DISABLE_LOCKS)
 117                                         return ;
 118
 119                                 // ADDED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 120                                 if (Enclosing_Instance.DisableLocks)
 121                                         return;
 122
 123                                 bool tmpBool;
 124                                 if (System.IO.File.Exists(lockFile.FullName))
 125                                 {
 126                                         System.IO.File.Delete(lockFile.FullName);
 127                                         tmpBool = true;
 128                                 }
 129                                 else if (System.IO.Directory.Exists(lockFile.FullName))
 130                                 {
 131                                         System.IO.Directory.Delete(lockFile.FullName);
 132                                         tmpBool = true;
 133                                 }
 134                                 else
 135                                         tmpBool = false;
 136
 137                                 // ADDED joeshaw@novell.com 10 Jan 2005 - lock debugging
 138                                 if (tmpBool)
 139                                         Log ("Released lock {0}", lockFile.FullName);
 140                                 else
 141                                         Log ("Failed to release lock {0}", lockFile.FullName);
 142                         }
 143                         public override bool IsLocked()
 144                         {
 145                                 if (Lucene.Net.Store.FSDirectory.DISABLE_LOCKS)
 146                                         return false;
 147
 148                                 // ADDED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 149                                 if (Enclosing_Instance.DisableLocks)
 150                                         return false;
 151
 152                                 bool tmpBool;
 153                                 if (System.IO.File.Exists(lockFile.FullName))
 154                                         tmpBool = true;
 155                                 else
 156                                         tmpBool = System.IO.Directory.Exists(lockFile.FullName);
 157                                 return tmpBool;
 158                         }
 159
 160                         public override System.String ToString()
 161                         {
 162                                 return "Lock@" + lockFile;
 163                         }
 164                 }
 165                 /// <summary>This cache of directories ensures that there is a unique Directory
 166                 /// instance per path, so that synchronization on the Directory can be used to
 167                 /// synchronize access between readers and writers.
 168                 ///
 169                 /// This should be a WeakHashMap, so that entries can be GC'd, but that would
 170                 /// require Java 1.2.  Instead we use refcounts...
 171                 /// </summary>
 172                 private static readonly System.Collections.Hashtable DIRECTORIES = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
 173
 174                 private static readonly bool DISABLE_LOCKS;
 175
 176                 /// <summary>
 177                 /// Get the name of the directory to use for temporary files,
 178                 /// and create that directory if it doesn't already exist
 179                 /// </summary>
 180                 /// FIXED trow@ximian.com 14 May 2004 Give us control over where locks are stored
 181                 /// FIXED trow@ximian.com 12 Sep 2004 make TempDirectoryName not be static
 182                 private String tempDirectoryName = null;
 183                 public String TempDirectoryName {
 184                         get {
 185                                 if (tempDirectoryName == null) {
 186                                         String user_name = Environment.GetEnvironmentVariable("USER");
 187                                         if (user_name == null)
 188                                                 user_name = "unknown";
 189                                         TempDirectoryName = "/tmp/" + user_name + "-lucene.net";
 190                                 }
 191                                 return tempDirectoryName;
 192                         }
 193
 194                         set {
 195                                 tempDirectoryName = value;
 196                                 if (! System.IO.Directory.Exists (tempDirectoryName))
 197                                         System.IO.Directory.CreateDirectory (tempDirectoryName);
 198                         }
 199                 }
 200
 201                 // ADDED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 202
 203                 private bool disable_locks = false;
 204
 205                 public bool DisableLocks {
 206                         get { return disable_locks; }
 207                         set { disable_locks = value; }
 208                 }
 209
 210         private static System.Security.Cryptography.MD5 DIGESTER;
 211
 212                 /// <summary>A buffer optionally used in renameTo method </summary>
 213                 private byte[] buffer = null;
 214
 215                 /// <summary>Returns the directory instance for the named location.
 216                 ///
 217                 /// <p>Directories are cached, so that, for a given canonical path, the same
 218                 /// FSDirectory instance will always be returned.  This permits
 219                 /// synchronization on directories.
 220                 ///
 221                 /// </summary>
 222                 /// <param name="path">the path to the directory.
 223                 /// </param>
 224                 /// <param name="create">if true, create, or erase any existing contents.
 225                 /// </param>
 226                 /// <returns> the FSDirectory for the named file.
 227                 /// </returns>
 228
 229                 /// CHANGED trow@novell.com 17 Mar 2005 set tmp dir at creation-time
 230                 /// CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 231                 public static FSDirectory GetDirectory(System.String path, System.String tmpDir, bool create)
 232                 {
 233                         return GetDirectory(new System.IO.FileInfo(path), tmpDir, create, false);
 234                 }
 235
 236                 // ADDED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 237                 public static FSDirectory GetDirectory(System.String path, System.String tmpDir, bool create, bool disable_locks)
 238                 {
 239                         return GetDirectory(new System.IO.FileInfo(path), tmpDir, create, disable_locks);
 240                 }
 241
 242                 // CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 243                 public static FSDirectory GetDirectory(System.String path, bool create)
 244                 {
 245                         return GetDirectory(new System.IO.FileInfo(path), null, create, false);
 246                 }
 247
 248                 /// <summary>Returns the directory instance for the named location.
 249                 ///
 250                 /// <p>Directories are cached, so that, for a given canonical path, the same
 251                 /// FSDirectory instance will always be returned.  This permits
 252                 /// synchronization on directories.
 253                 ///
 254                 /// </summary>
 255                 /// <param name="file">the path to the directory.
 256                 /// </param>
 257                 /// <param name="create">if true, create, or erase any existing contents.
 258                 /// </param>
 259                 /// <returns> the FSDirectory for the named file.
 260                 /// </returns>
 261                 /// CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 262                 public static FSDirectory GetDirectory(System.IO.FileInfo file, System.String tmpDir, bool create, bool disable_locks)
 263                 {
 264                         file = new System.IO.FileInfo(file.FullName);
 265                         FSDirectory dir;
 266                         lock (DIRECTORIES.SyncRoot)
 267                         {
 268                                 dir = (FSDirectory) DIRECTORIES[file];
 269                                 if (dir == null)
 270                                 {
 271                                         // CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 272                                         dir = new FSDirectory(file, tmpDir, create, disable_locks);
 273                                         DIRECTORIES[file] = dir;
 274                                 }
 275                                 else if (create)
 276                                 {
 277                                         dir.Create();
 278                                 }
 279                         }
 280                         lock (dir)
 281                         {
 282                                 dir.refCount++;
 283                         }
 284                         return dir;
 285                 }
 286
 287                 // CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 288                 public static FSDirectory GetDirectory(System.IO.FileInfo file, bool create)
 289                 {
 290                         return GetDirectory (file, null, create, false);
 291                 }
 292
 293                 private System.IO.FileInfo directory = null;
 294                 private int refCount;
 295                 private System.IO.FileInfo lockDir;
 296
 297                 /// CHANGED fhedberg@novell.com 16 Jun 2005 - disable locks per directory
 298                 private FSDirectory(System.IO.FileInfo path, string tmpDir, bool create, bool disable_locks)
 299                 {
 300                         directory = path;
 301                         this.disable_locks = disable_locks;
 302
 303                         // FIXED joeshaw@novell.com  10 Jan 2005  Use TempDirectoryName to find where locks live
 304                         // FIXED trow@novell.com  17 Mar 2005  A fix on the fix
 305                         if (tmpDir != null)
 306                                 TempDirectoryName = tmpDir;
 307                         lockDir = new System.IO.FileInfo (TempDirectoryName);
 308                         if (create)
 309                         {
 310                                 Create();
 311                         }
 312
 313                         if (!System.IO.Directory.Exists(directory.FullName))
 314                                 throw new System.IO.IOException(path + " not a directory");
 315                 }
 316
 317                 private void  Create()
 318                 {
 319                         lock (this)
 320                         {
 321                                 bool tmpBool;
 322                                 if (System.IO.File.Exists(directory.FullName))
 323                                         tmpBool = true;
 324                                 else
 325                                         tmpBool = System.IO.Directory.Exists(directory.FullName);
 326                                 if (!tmpBool)
 327                                 {
 328                     try
 329                     {
 330                         System.IO.Directory.CreateDirectory(directory.FullName);
 331                     }
 332                     catch (Exception)
 333                     {
 334                         throw new System.IO.IOException("Cannot create directory: " + directory);
 335                     }
 336                                 }
 337
 338                                 System.String[] files = System.IO.Directory.GetFileSystemEntries(directory.FullName); // clear old files
 339                                 for (int i = 0; i < files.Length; i++)
 340                                 {
 341                                         System.IO.FileInfo file = new System.IO.FileInfo(files[i]);
 342                                         bool tmpBool2;
 343                                         if (System.IO.File.Exists(file.FullName))
 344                                         {
 345                                                 System.IO.File.Delete(file.FullName);
 346                                                 tmpBool2 = true;
 347                                         }
 348                                         else if (System.IO.Directory.Exists(file.FullName))
 349                                         {
 350                                                 System.IO.Directory.Delete(file.FullName);
 351                                                 tmpBool2 = true;
 352                                         }
 353                                         else
 354                                                 tmpBool2 = false;
 355                                         if (!tmpBool2)
 356                                                 throw new System.IO.IOException("Cannot delete " + files[i]);
 357                                 }
 358
 359                                 System.String lockPrefix = GetLockPrefix().ToString(); // clear old locks
 360                                 files = System.IO.Directory.GetFileSystemEntries(lockDir.FullName);
 361                                 for (int i = 0; i < files.Length; i++)
 362                                 {
 363                                         if (!files[i].StartsWith(lockPrefix))
 364                                                 continue;
 365                                         System.IO.FileInfo lockFile = new System.IO.FileInfo(System.IO.Path.Combine(lockDir.FullName, files[i]));
 366                                         bool tmpBool3;
 367                                         if (System.IO.File.Exists(lockFile.FullName))
 368                                         {
 369                                                 System.IO.File.Delete(lockFile.FullName);
 370                                                 tmpBool3 = true;
 371                                         }
 372                                         else if (System.IO.Directory.Exists(lockFile.FullName))
 373                                         {
 374                                                 System.IO.Directory.Delete(lockFile.FullName);
 375                                                 tmpBool3 = true;
 376                                         }
 377                                         else
 378                                                 tmpBool3 = false;
 379                                         if (!tmpBool3)
 380                                                 throw new System.IO.IOException("Cannot delete " + files[i]);
 381                                 }
 382                         }
 383                 }
 384
 385                 /// <summary>Returns an array of strings, one for each file in the directory. </summary>
 386                 public override System.String[] List()
 387                 {
 388                         return System.IO.Directory.GetFileSystemEntries(directory.FullName);
 389                 }
 390
 391                 /// <summary>Returns true iff a file with the given name exists. </summary>
 392                 public override bool FileExists(System.String name)
 393                 {
 394                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 395                         bool tmpBool;
 396                         if (System.IO.File.Exists(file.FullName))
 397                                 tmpBool = true;
 398                         else
 399                                 tmpBool = System.IO.Directory.Exists(file.FullName);
 400                         return tmpBool;
 401                 }
 402
 403                 /// <summary>Returns the time the named file was last modified. </summary>
 404                 public override long FileModified(System.String name)
 405                 {
 406                         // FIXED joeshaw@novell.com 24 Jun 2005 - Use UTC
 407                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 408                         return ((file.LastWriteTimeUtc.Ticks - 621355968000000000) / 10000);
 409                 }
 410
 411                 /// <summary>Returns the time the named file was last modified. </summary>
 412                 public static long FileModified(System.IO.FileInfo directory, System.String name)
 413                 {
 414                         // FIXED joeshaw@novell.com 24 Jun 2005 - Use UTC
 415                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 416                         return ((file.LastWriteTimeUtc.Ticks - 621355968000000000) / 10000);
 417                 }
 418
 419                 /// <summary>Set the modified time of an existing file to now. </summary>
 420                 public override void  TouchFile(System.String name)
 421                 {
 422                         // FIXED joeshaw@novell.com 24 Jun 2005 - Use UTC
 423                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 424                         file.LastWriteTimeUtc = System.DateTime.UtcNow;
 425                 }
 426
 427                 /// <summary>Returns the length in bytes of a file in the directory. </summary>
 428                 public override long FileLength(System.String name)
 429                 {
 430                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 431             return file.Exists ? file.Length : 0;
 432                 }
 433
 434                 /// <summary>Removes an existing file in the directory. </summary>
 435                 public override void  DeleteFile(System.String name)
 436                 {
 437                         System.IO.FileInfo file = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name));
 438                         bool tmpBool;
 439                         if (System.IO.File.Exists(file.FullName))
 440                         {
 441                                 System.IO.File.Delete(file.FullName);
 442                                 tmpBool = true;
 443                         }
 444                         else if (System.IO.Directory.Exists(file.FullName))
 445                         {
 446                                 System.IO.Directory.Delete(file.FullName);
 447                                 tmpBool = true;
 448                         }
 449                         else
 450                                 tmpBool = false;
 451                         if (!tmpBool)
 452                                 throw new System.IO.IOException("Cannot delete " + name);
 453                 }
 454
 455                 /// <summary>Renames an existing file in the directory. </summary>
 456                 public override void  RenameFile(System.String from, System.String to)
 457                 {
 458                         lock (this)
 459                         {
 460                                 System.IO.FileInfo old = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, from));
 461                                 System.IO.FileInfo nu = new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, to));
 462
 463                                 /* This is not atomic.  If the program crashes between the call to
 464                                 delete() and the call to renameTo() then we're screwed, but I've
 465                                 been unable to figure out how else to do this... */
 466
 467                                 bool tmpBool;
 468                                 if (System.IO.File.Exists(nu.FullName))
 469                                         tmpBool = true;
 470                                 else
 471                                         tmpBool = System.IO.Directory.Exists(nu.FullName);
 472                                 if (tmpBool)
 473                                 {
 474                                         bool tmpBool2;
 475                                         if (System.IO.File.Exists(nu.FullName))
 476                                         {
 477                                                 System.IO.File.Delete(nu.FullName);
 478                                                 tmpBool2 = true;
 479                                         }
 480                                         else if (System.IO.Directory.Exists(nu.FullName))
 481                                         {
 482                                                 System.IO.Directory.Delete(nu.FullName);
 483                                                 tmpBool2 = true;
 484                                         }
 485                                         else
 486                                                 tmpBool2 = false;
 487                                         if (!tmpBool2)
 488                                                 throw new System.IO.IOException("Cannot delete " + to);
 489                                 }
 490
 491                                 // Rename the old file to the new one. Unfortunately, the renameTo()
 492                                 // method does not work reliably under some JVMs.  Therefore, if the
 493                                 // rename fails, we manually rename by copying the old file to the new one
 494                 try
 495                 {
 496                     old.MoveTo(nu.FullName);
 497                 }
 498                 catch (System.Exception ex)
 499                 {
 500                     System.IO.BinaryReader in_Renamed = null;
 501                     System.IO.Stream out_Renamed = null;
 502                     try
 503                     {
 504                         in_Renamed = new System.IO.BinaryReader(System.IO.File.Open(old.FullName, System.IO.FileMode.Open, System.IO.FileAccess.Read));
 505                         // FIXED trow@novell.com 18 Jul 2005
 506                         // Open the FileStream w/ FileShare.ReadWrite.
 507                         out_Renamed = new System.IO.FileStream(nu.FullName, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
 508                         // see if the buffer needs to be initialized. Initialization is
 509                         // only done on-demand since many VM's will never run into the renameTo
 510                         // bug and hence shouldn't waste 1K of mem for no reason.
 511                         if (buffer == null)
 512                         {
 513                             buffer = new byte[1024];
 514                         }
 515                         int len;
 516                         len = in_Renamed.Read(buffer, 0, buffer.Length);
 517                         out_Renamed.Write(buffer, 0, len);
 518
 519                         // FIXED trow@novell.com 18 Feb 2005
 520                         // Commented out unused variables tmpBool3 and generatedAux
 521                         // to avoid compiler warnings
 522
 523                         // delete the old file.
 524                         // bool tmpBool3;
 525                         if (System.IO.File.Exists(old.FullName))
 526                         {
 527                             System.IO.File.Delete(old.FullName);
 528                             // tmpBool3 = true;
 529                         }
 530                         else if (System.IO.Directory.Exists(old.FullName))
 531                         {
 532                             System.IO.Directory.Delete(old.FullName);
 533                             // tmpBool3 = true;
 534                         }
 535                         //else
 536                         //tmpBool3 = false;
 537                         //bool generatedAux = tmpBool3;
 538                     }
 539                     catch (System.IO.IOException e)
 540                     {
 541                         throw new System.IO.IOException("Cannot rename " + from + " to " + to);
 542                     }
 543                     finally
 544                     {
 545                         if (in_Renamed != null)
 546                         {
 547                             try
 548                             {
 549                                 in_Renamed.Close();
 550                             }
 551                             catch (System.IO.IOException e)
 552                             {
 553                                 throw new System.SystemException("Cannot close input stream: " + e.Message);
 554                             }
 555                         }
 556                         if (out_Renamed != null)
 557                         {
 558                             try
 559                             {
 560                                 out_Renamed.Close();
 561                             }
 562                             catch (System.IO.IOException e)
 563                             {
 564                                 throw new System.SystemException("Cannot close output stream: " + e.Message);
 565                             }
 566                         }
 567                     }
 568                 }
 569                         }
 570                 }
 571
 572                 /// <summary>Creates a new, empty file in the directory with the given name.
 573                 /// Returns a stream writing this file.
 574                 /// </summary>
 575                 public override OutputStream CreateFile(System.String name)
 576                 {
 577                         return new FSOutputStream(new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name)));
 578                 }
 579
 580                 /// <summary>Returns a stream reading an existing file. </summary>
 581                 public override InputStream OpenFile(System.String name)
 582                 {
 583                         return new FSInputStream(new System.IO.FileInfo(System.IO.Path.Combine(directory.FullName, name)));
 584                 }
 585
 586                 // ADDED trow 4 June 2004
 587                 static public Beagle.Util.Logger Logger = null;
 588                 //static public Beagle.Util.Logger Logger = Beagle.Util.Logger.Log;
 589                 static private void Log (string format, params object[] args)
 590                 {
 591                         if (Logger != null)
 592                                 Logger.Debug (format, args);
 593                 }
 594                 static private void Log (Exception e)
 595                 {
 596                         if (Logger != null)
 597                                 Logger.Debug (e);
 598                 }
 599
 600                 /// <summary> So we can do some byte-to-hexchar conversion below</summary>
 601                 private static readonly char[] HEX_DIGITS = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 602
 603                 /// <summary>Constructs a {@link Lock} with the specified name.  Locks are implemented
 604                 /// with {@link File#createNewFile() }.
 605                 ///
 606                 /// <p>In JDK 1.1 or if system property <I>disableLuceneLocks</I> is the
 607                 /// string "true", locks are disabled.  Assigning this property any other
 608                 /// string will <B>not</B> prevent creation of lock files.  This is useful for
 609                 /// using Lucene on read-only medium, such as CD-ROM.
 610                 ///
 611                 /// </summary>
 612                 /// <param name="name">the name of the lock file
 613                 /// </param>
 614                 /// <returns> an instance of <code>Lock</code> holding the lock
 615                 /// </returns>
 616                 public override Lock MakeLock(System.String name)
 617                 {
 618                         System.Text.StringBuilder buf = GetLockPrefix();
 619                         buf.Append("-");
 620                         buf.Append(name);
 621
 622                         // create a lock file
 623                         System.IO.FileInfo lockFile = new System.IO.FileInfo(System.IO.Path.Combine(lockDir.FullName, buf.ToString()));
 624
 625                         return new AnonymousClassLock(lockFile, this);
 626                 }
 627
 628                 private System.Text.StringBuilder GetLockPrefix()
 629                 {
 630                         System.String dirName; // name to be hashed
 631                         try
 632                         {
 633                                 dirName = directory.FullName;
 634                         }
 635                         catch (System.IO.IOException e)
 636                         {
 637                                 throw new System.SystemException(e.ToString());
 638                         }
 639
 640                         byte[] digest;
 641                         lock (DIGESTER)
 642                         {
 643                                 digest = DIGESTER.ComputeHash(System.Text.Encoding.UTF8.GetBytes(dirName));
 644                         }
 645                         System.Text.StringBuilder buf = new System.Text.StringBuilder();
 646                         buf.Append("lucene-");
 647                         for (int i = 0; i < digest.Length; i++)
 648                         {
 649                                 int b = digest[i];
 650                                 buf.Append(HEX_DIGITS[(b >> 4) & 0xf]);
 651                                 buf.Append(HEX_DIGITS[b & 0xf]);
 652                         }
 653
 654                         return buf;
 655                 }
 656
 657                 /// <summary>Closes the store to future operations. </summary>
 658                 public override void  Close()
 659                 {
 660                         lock (this)
 661                         {
 662                                 if (--refCount <= 0)
 663                                 {
 664                                         lock (DIRECTORIES.SyncRoot)
 665                                         {
 666                                                 DIRECTORIES.Remove(directory);
 667                                         }
 668                                 }
 669                         }
 670                 }
 671
 672                 public System.IO.FileInfo GetFile()
 673                 {
 674                         return directory;
 675                 }
 676
 677                 /// <summary>For debug output. </summary>
 678                 public override System.String ToString()
 679                 {
 680                         return "FSDirectory@" + directory;
 681                 }
 682                 static FSDirectory()
 683                 {
 684                         DISABLE_LOCKS = System.Configuration.ConfigurationSettings.AppSettings.Get("disableLuceneLocks") != null;
 685                         {
 686                                 try
 687                                 {
 688                                         DIGESTER = System.Security.Cryptography.MD5.Create();
 689                                 }
 690                                 catch (System.Exception e)
 691                                 {
 692                                         throw new System.SystemException(e.ToString());
 693                                 }
 694                         }
 695                 }
 696         }
 697
 698
 699         sealed public class FSInputStream : InputStream, System.ICloneable
 700         {
 701                 internal class Descriptor : System.IO.BinaryReader
 702                 {
 703                         private void  InitBlock(FSInputStream enclosingInstance)
 704                         {
 705                                 this.enclosingInstance = enclosingInstance;
 706                         }
 707                         private FSInputStream enclosingInstance;
 708                         public FSInputStream Enclosing_Instance
 709                         {
 710                                 get
 711                                 {
 712                                         return enclosingInstance;
 713                                 }
 714
 715                         }
 716                         /* DEBUG */
 717                         //private String name;
 718                         /* DEBUG */
 719             // {{Aroush
 720                         public long position;
 721             public Descriptor(FSInputStream enclosingInstance, System.IO.FileInfo file, System.IO.FileAccess fileAccess)
 722                 : base(new System.IO.FileStream(file.FullName, System.IO.FileMode.Open, fileAccess, System.IO.FileShare.ReadWrite))
 723             {
 724             }
 725
 726                         //{{}}// public Descriptor(FSInputStream enclosingInstance, System.IO.FileInfo file, System.String mode) : base(file, mode)
 727                         //{{}}// {
 728                         //{{}}//        InitBlock(enclosingInstance);
 729                         //{{}}//        /* DEBUG */
 730                         //{{}}//        //name = file.ToString();
 731                         //{{}}//        //debug_printInfo("OPEN");
 732                         //{{}}//        /* DEBUG */
 733                         //{{}}// }
 734             // Aroush}}
 735
 736                         /* DEBUG */
 737                         //public void close() throws IOException {
 738                         //  debug_printInfo("CLOSE");
 739                         //    super.close();
 740                         //}
 741                         //
 742                         //private void debug_printInfo(String op) {
 743                         //  try { throw new Exception(op + " <" + name + ">");
 744                         //  } catch (Exception e) {
 745                         //    java.io.StringWriter sw = new java.io.StringWriter();
 746                         //    java.io.PrintWriter pw = new java.io.PrintWriter(sw);
 747                         //    e.printStackTrace(pw);
 748                         //    System.out.println(sw.getBuffer().ToString());
 749                         //  }
 750                         //}
 751                         /* DEBUG */
 752                 }
 753
 754                 internal Descriptor file = null;
 755                 public /*internal*/ bool isClone;
 756
 757                 public FSInputStream(System.IO.FileInfo path)
 758                 {
 759                         file = new Descriptor(this, path, System.IO.FileAccess.Read);
 760                         length = file.BaseStream.Length;
 761                 }
 762
 763                 /// <summary>InputStream methods </summary>
 764                 public override void  ReadInternal(byte[] b, int offset, int len)
 765                 {
 766                         lock (file)
 767                         {
 768                                 long position = GetFilePointer();
 769                                 if (position != file.position)
 770                                 {
 771                                         file.BaseStream.Seek(position, System.IO.SeekOrigin.Begin);
 772                                         file.position = position;
 773                                 }
 774                                 int total = 0;
 775                                 do
 776                                 {
 777                     int i = file.Read(b, offset + total, len - total);
 778                                         if (i <= 0)
 779                                                 throw new System.IO.IOException("read past EOF");
 780                                         file.position += i;
 781                                         total += i;
 782                                 }
 783                                 while (total < len);
 784                         }
 785                 }
 786
 787                 public override void  Close()
 788                 {
 789                         if (!isClone && file != null)
 790                                 file.Close();
 791                         System.GC.SuppressFinalize(this);
 792                 }
 793
 794                 /// <summary>Random-access methods </summary>
 795                 public override void  SeekInternal(long position)
 796                 {
 797                 }
 798
 799                 ~FSInputStream()
 800                 {
 801                         Close(); // close the file
 802                 }
 803
 804                 public override System.Object Clone()
 805                 {
 806                         FSInputStream clone = (FSInputStream) base.Clone();
 807                         clone.isClone = true;
 808                         return clone;
 809                 }
 810
 811                 /// <summary>Method used for testing. Returns true if the underlying
 812                 /// file descriptor is valid.
 813                 /// </summary>
 814                 public /*internal*/ bool IsFDValid()
 815                 {
 816                         return file.BaseStream.CanRead;
 817                 }
 818         }
 819
 820
 821         sealed class FSOutputStream : OutputStream
 822         {
 823                 internal System.IO.BinaryWriter file = null;
 824
 825                 public FSOutputStream(System.IO.FileInfo path)
 826                 {
 827                         file = new System.IO.BinaryWriter(new System.IO.FileStream(path.FullName, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite));
 828                 }
 829
 830                 /// <summary>output methods: </summary>
 831                 public override void  FlushBuffer(byte[] b, int size)
 832                 {
 833             file.Write(b, 0, size);
 834                 }
 835                 public override void  Close()
 836                 {
 837                         base.Close();
 838                         file.Close();
 839                         System.GC.SuppressFinalize(this);
 840                 }
 841
 842                 /// <summary>Random-access methods </summary>
 843                 public override void  Seek(long pos)
 844                 {
 845                         base.Seek(pos);
 846                         file.BaseStream.Seek(pos, System.IO.SeekOrigin.Begin);
 847                 }
 848                 public override long Length()
 849                 {
 850                         return file.BaseStream.Length;
 851                 }
 852
 853                 ~FSOutputStream()
 854                 {
 855                         file.Close(); // close the file
 856                 }
 857         }
 858 }