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."); }
public AnonymousWith(Lock @lock, int lockWaitTimeout, Func <T> doBody) : base(@lock, lockWaitTimeout) { this.doBody = doBody ?? throw new ArgumentNullException(nameof(doBody)); }
/// <summary> /// Creates a new instance with the ability to specify the <see cref="With{T}.DoBody()"/> method /// through the <paramref name="doBody"/> argument /// <para/> /// Simple example: /// <code> /// var result = Lock.With.NewAnonymous<string>( /// @lock: directory.MakeLock("my.lock"), /// lockWaitTimeout: Lock.LOCK_OBTAIN_WAIT_FOREVER, /// doBody: () => /// { /// //... code to execute while locked ... /// return "the result"; /// }).Run(); /// </code> /// <para/> /// The result of the operation is the value that is returned from <paramref name="doBody"/> /// (i.e. () => { return "the result"; }). The type of <typeparam name="T"/> determines the /// return type of the operation. /// </summary> /// <param name="lock"> the <see cref="Lock"/> instance to use </param> /// <param name="lockWaitTimeout"> length of time to wait in /// milliseconds or /// <see cref="LOCK_OBTAIN_WAIT_FOREVER"/> to retry forever </param> /// <param name="doBody"> a delegate method that </param> /// <returns>The value that is returned from the <paramref name="doBody"/> delegate method (i.e. () => { return theObject; })</returns> public static With <T> NewAnonymous <T>(Lock @lock, int lockWaitTimeout, Func <T> doBody) { return(new AnonymousWith <T>(@lock, lockWaitTimeout, doBody)); }
private readonly long lockWaitTimeout; // LUCENENET: marked readonly /// <summary> /// Constructs an executor that will grab the named <paramref name="lock"/>. </summary> /// <param name="lock"> the <see cref="Lock"/> instance to use </param> /// <param name="lockWaitTimeout"> length of time to wait in /// milliseconds or /// <see cref="LOCK_OBTAIN_WAIT_FOREVER"/> to retry forever </param> protected With(Lock @lock, long lockWaitTimeout) // LUCENENET: CA1012: Abstract types should not have constructors (marked protected) { this.@lock = @lock; this.lockWaitTimeout = lockWaitTimeout; }