public override IndexInputSlicer CreateSlicer(string name, IOContext context) { lock (this) { EnsureOpen(); if (VERBOSE) { Console.WriteLine("nrtdir.openInput name=" + name); } #pragma warning disable 612, 618 if (cache.FileExists(name)) #pragma warning restore 612, 618 { if (VERBOSE) { Console.WriteLine(" from cache"); } return(cache.CreateSlicer(name, context)); } else { return(@delegate.CreateSlicer(name, context)); } } }
public override void Sync(ICollection <string> fileNames) { if (VERBOSE) { Console.WriteLine("nrtdir.sync files=" + fileNames); } foreach (string fileName in fileNames) { UnCache(fileName); } @delegate.Sync(fileNames); }
public override void DeleteFile(string name) { lock (this) { if (VERBOSE) { Console.WriteLine("nrtdir.deleteFile name=" + name); } #pragma warning disable 612, 618 if (cache.FileExists(name)) #pragma warning restore 612, 618 { cache.DeleteFile(name); } else { @delegate.DeleteFile(name); } } }
private void UnCache(string fileName) { // Only let one thread uncache at a time; this only // happens during commit() or close(): lock (uncacheLock) { if (VERBOSE) { Console.WriteLine("nrtdir.unCache name=" + fileName); } #pragma warning disable 612, 618 if (!cache.FileExists(fileName)) #pragma warning restore 612, 618 { // Another thread beat us... return; } IOContext context = IOContext.DEFAULT; IndexOutput @out = @delegate.CreateOutput(fileName, context); IndexInput @in = null; try { @in = cache.OpenInput(fileName, context); @out.CopyBytes(@in, @in.Length); } finally { IOUtils.Dispose(@in, @out); } // Lock order: uncacheLock -> this lock (this) { // Must sync here because other sync methods have // if (cache.fileExists(name)) { ... } else { ... }: cache.DeleteFile(fileName); } } }
public override IndexOutput CreateOutput(string name, IOContext context) { if (VERBOSE) { Console.WriteLine("nrtdir.createOutput name=" + name); } if (DoCacheWrite(name, context)) { if (VERBOSE) { Console.WriteLine(" to cache"); } try { @delegate.DeleteFile(name); } #pragma warning disable 168 catch (IOException ioe) #pragma warning restore 168 { // this is fine: file may not exist } return(cache.CreateOutput(name, context)); } else { try { cache.DeleteFile(name); } #pragma warning disable 168 catch (IOException ioe) #pragma warning restore 168 { // this is fine: file may not exist } return(@delegate.CreateOutput(name, context)); } }
public static void Main(string[] args) { if (args.Length != 7) { // LUCENENET specific - our wrapper console shows the correct usage throw new ArgumentException(); //Console.WriteLine("Usage: java Lucene.Net.Store.LockStressTest myID verifierHost verifierPort lockFactoryClassName lockDirName sleepTimeMS count\n" + // "\n" + // " myID = int from 0 .. 255 (should be unique for test process)\n" + // " verifierHost = hostname that LockVerifyServer is listening on\n" + // " verifierPort = port that LockVerifyServer is listening on\n" + // " lockFactoryClassName = primary LockFactory class that we will use\n" + // " lockDirName = path to the lock directory (only set for Simple/NativeFSLockFactory\n" + // " sleepTimeMS = milliseconds to pause betweeen each lock obtain/release\n" + // " count = number of locking tries\n" + // "\n" + // "You should run multiple instances of this process, each with its own\n" + // "unique ID, and each pointing to the same lock directory, to verify\n" + // "that locking is working correctly.\n" + // "\n" + // "Make sure you are first running LockVerifyServer."); //Environment.FailFast("1"); } int arg = 0; int myID = Convert.ToInt32(args[arg++], CultureInfo.InvariantCulture); if (myID < 0 || myID > 255) { throw new ArgumentException("ID must be a unique int 0..255"); //Console.WriteLine("myID must be a unique int 0..255"); //Environment.Exit(1); } string verifierHost = args[arg++]; int verifierPort = Convert.ToInt32(args[arg++], CultureInfo.InvariantCulture); string lockFactoryClassName = args[arg++]; string lockDirName = args[arg++]; int sleepTimeMS = Convert.ToInt32(args[arg++], CultureInfo.InvariantCulture); int count = Convert.ToInt32(args[arg++], CultureInfo.InvariantCulture); IPAddress[] addresses = Dns.GetHostAddressesAsync(verifierHost).Result; IPAddress addr = addresses.FirstOrDefault(); Type c; try { c = Type.GetType(lockFactoryClassName); if (c == null) { // LUCENENET: try again, this time with the Store namespace c = Type.GetType("Lucene.Net.Store." + lockFactoryClassName); } } catch (Exception) { throw new IOException("unable to find LockClass " + lockFactoryClassName); } LockFactory lockFactory; try { lockFactory = (LockFactory)Activator.CreateInstance(c); } catch (UnauthorizedAccessException e) { throw new IOException("Cannot instantiate lock factory " + lockFactoryClassName, e); } catch (InvalidCastException e) { throw new IOException("unable to cast LockClass " + lockFactoryClassName + " instance to a LockFactory", e); } catch (Exception e) { throw new IOException("InstantiationException when instantiating LockClass " + lockFactoryClassName, e); } DirectoryInfo lockDir = new DirectoryInfo(lockDirName); if (lockFactory is FSLockFactory) { ((FSLockFactory)lockFactory).SetLockDir(lockDir); } Console.WriteLine("Connecting to server " + addr + " and registering as client " + myID + "..."); using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); socket.Connect(verifierHost, verifierPort); using (Stream stream = new NetworkStream(socket)) { BinaryReader intReader = new BinaryReader(stream); BinaryWriter intWriter = new BinaryWriter(stream); intWriter.Write(myID); stream.Flush(); lockFactory.LockPrefix = "test"; LockFactory verifyLF = new VerifyingLockFactory(lockFactory, stream); Lock l = verifyLF.MakeLock("test.lock"); Random rnd = new Random(); // wait for starting gun if (intReader.ReadInt32() != 43) { throw new IOException("Protocol violation"); } for (int i = 0; i < count; i++) { bool obtained = false; try { obtained = l.Obtain(rnd.Next(100) + 10); } #pragma warning disable 168 catch (LockObtainFailedException e) #pragma warning restore 168 { } if (obtained) { Thread.Sleep(sleepTimeMS); l.Dispose(); } if (i % 500 == 0) { Console.WriteLine((i * 100.0 / count) + "% done."); } Thread.Sleep(sleepTimeMS); } } } Console.WriteLine("Finished " + count + " tries."); }