public void TestDebugFactoryRecursiveOptions() { DebugLockFactory <SimpleReadWriteLocking> factory = new DebugLockFactory <SimpleReadWriteLocking>( false, 0, 1, false, 1); using (ILockStrategy lck = factory.Create()) { using (lck.Write()) using (lck.Write()) //second lock, allow recurse 1 time as per constructor { try { using (lck.Write()) { Assert.Fail(); } } catch (Exception ex) { Assert.IsTrue(ex is DebugAssertionFailedException);//nesting prohibited by debug lock } } using (lck.Read()) using (lck.Read()) //second lock, allow recurse 1 time as per constructor { try { using (lck.Read()) { Assert.Fail(); } } catch (Exception ex) { Assert.IsTrue(ex is DebugAssertionFailedException);//nesting prohibited by debug lock } } } }
public ThreadSafeWorkingMemory(bool supportHotSwap, int lockTimeOut) { this.lockTimeOut = lockTimeOut; if (supportHotSwap) lockStrategy = new ReaderWriterLockStrategy(); else lockStrategy = new NoLockStrategy(); }
public void TestWriteLockTimeout() { using (ILockStrategy l = LockFactory.Create()) using (new ThreadedWriter(l)) using (WriteLock w = new WriteLock(l, 0)) Assert.IsFalse(w.HasWriteLock); }
public void TestReadLockTimeout() { using (ILockStrategy l = LockFactory.Create()) using (new ThreadedWriter(l)) using (ReadLock r = new ReadLock(l, 0)) Assert.IsFalse(r.HasReadLock); }
public override void TestWriteCounter() { using (ILockStrategy l = LockFactory.Create()) { Assert.AreEqual(0, l.WriteVersion); Assert.IsTrue(l.TryRead(0)); l.ReleaseRead(); Assert.AreEqual(0, l.WriteVersion); Assert.IsTrue(l.TryWrite(0)); Assert.AreEqual(0, l.WriteVersion); l.ReleaseWrite(); Assert.AreEqual(0, l.WriteVersion); using (l.Write()) { Assert.AreEqual(0, l.WriteVersion); Assert.IsTrue(l.TryWrite(0)); // Once a nested write lock is acquired the real lock is obtained. Assert.AreEqual(1, l.WriteVersion); l.ReleaseWrite(); Assert.AreEqual(1, l.WriteVersion); } Assert.IsTrue(l.TryWrite(0)); l.ReleaseWrite(); Assert.AreEqual(1, l.WriteVersion); } }
protected Node CreateRoot(NodeHandle rootHandle) { NodeHandle hChild; using (NodeTransaction t = BeginTransaction()) { using (NodePin child = t.Create(LockType.Insert, true)) { hChild = child.Handle; t.Commit(); } } object refobj; RootNode rootNode = new RootNode(rootHandle.StoreHandle); ILockStrategy lck = CreateLock(rootHandle, out refobj); using (lck.Write(Options.LockTimeout)) { using (NodePin rootPin = new NodePin(rootHandle, lck, LockType.Insert, LockType.Insert, refobj, rootNode, null)) using (NodeTransaction t = BeginTransaction()) { rootNode = (RootNode)t.BeginUpdate(rootPin); rootNode.ReplaceChild(0, null, hChild); t.Commit(); } } return(rootNode); }
public void TestYouCanDisposeWriteLock() { using (ILockStrategy l = LockFactory.Create()) using (IDisposable w = l.Write()) { w.Dispose();//since the using statement has the same boxed pointer to w, we are allowed to dispose } }
public void TestYouCanDisposeReadLock() { using (ILockStrategy l = LockFactory.Create()) using (IDisposable r = ReadLock.Acquire(l, 0)) { r.Dispose();//since the using statement has the same boxed pointer to r, we are allowed to dispose } }
public void TestTryWrite() { using (ILockStrategy l = LockFactory.Create()) { Assert.IsTrue(l.TryWrite(0)); l.ReleaseWrite(); } }
public StorageCache(INodeStorage store, int sizeLimit) { _store = store; _sizeLimit = sizeLimit; _lock = new SimpleReadWriteLocking(); _cache = new Dictionary <IStorageHandle, StorageInfo>(); _ordered = new Queue <IStorageHandle>(); }
/// <summary> Acquires the lock within the timeout or throws TimeoutException </summary> /// <exception cref="System.TimeoutException"/> public static WriteLock Acquire(ILockStrategy lck, int timeout) { if (!lck.TryWrite(timeout)) { throw new TimeoutException(); } return(new WriteLock(lck, true)); }
public void TestIdiotWriterUsesDispose() { using (ILockStrategy l = LockFactory.Create()) using (WriteLock w = new WriteLock(l, 0)) { Assert.IsTrue(w.HasWriteLock); ((IDisposable)w).Dispose(); //You cannot do this, the using statement has a 'copy' of ReadLock, don't call dispose. } }
public void TestWriteRecursion() { ILockStrategy l = LockFactory.Create(); using (l.Write()) using (l.Write()) using (l.Write()) { } }
public void TestThreadedReadTimeout() { using (ILockStrategy l = LockFactory.Create()) { using (new ThreadedWriter(l)) using (l.Read(0)) { } } }
public void NoWriteIncrement() { using (ILockStrategy l = LockFactory.Create()) { Assert.AreEqual(0, l.WriteVersion); using (l.Write()) Assert.AreEqual(0, l.WriteVersion); Assert.AreEqual(0, l.WriteVersion); } }
public virtual void TestReaderAllowsReader() { using (ILockStrategy l = LockFactory.Create()) { using (new ThreadedReader(l)) Assert.IsTrue(l.TryRead(0)); l.ReleaseRead(); } }
public virtual void TestWriteToReadRecursion() { using (ILockStrategy l = LockFactory.Create()) { using (l.Write()) using (l.Read()) using (l.Read()) { } } }
public void TestWriteThenReadWithTimeout() { using (ILockStrategy l = LockFactory.Create()) { using (l.Write(0)) { } using (l.Read(0)) { } } }
public void TestReadThenWrite() { using (ILockStrategy l = LockFactory.Create()) { using (l.Read()) { } using (l.Write()) { } } }
public ThreadSafeWorkingMemory(bool supportHotSwap) { if (supportHotSwap) { lockStrategy = new ReaderWriterLockStrategy(); } else { lockStrategy = new NoLockStrategy(); } }
public NodePin(NodeHandle handle, ILockStrategy lck, LockType ltype, LockType lockHeld, object refobj, Node original, Node updated) { Assert(original == null || original.IsReadOnly); _handle = handle; _lock = lck; _ltype = ltype; _lockHeld = lockHeld; _ptr = original; _temp = updated; _reference = refobj; }
public NodePin Create(LockType ltype, bool isLeaf) { IStorageHandle storeHandle = _cache.Storage.Create(); NodeHandle handle = new NodeHandle(storeHandle); object refobj; ILockStrategy lck = _cache.CreateLock(handle, out refobj); int size = isLeaf ? _cache.Options.MaximumValueNodes : _cache.Options.MaximumChildNodes; NodePin pin = new NodePin(handle, lck, ltype, LockType.Insert, refobj, null, new Node(handle.StoreHandle, size)); NodePin.Append(ref _created, pin); return(pin); }
protected void DoubleWriteLock() { using (ILockStrategy strategy = this.GetLockStrategy()) { using (var writeLock1 = strategy.GetWriteLock()) { using (var writeLock2 = strategy.GetWriteLock()) { // do nothing } } } }
public Chain(string name, ILockStrategy lockStrategy, IConnector <T> rootConnector, IConnector[] connectors, ISourceConnector <T>[] sourceConnectors, IServiceProvider serviceProvider, Queue <InitDelegate> initQueue) { _serviceProvider = serviceProvider; _logger = serviceProvider.GetRequiredService <ILogger <IChain> >(); _initQueue = initQueue; Name = name; LockStrategy = lockStrategy; _root = rootConnector; Connectors = connectors; _sourceConnectors = sourceConnectors; }
public ThreadSafeWorkingMemory(bool supportHotSwap, int lockTimeOut) { this.lockTimeOut = lockTimeOut; if (supportHotSwap) { lockStrategy = new ReaderWriterLockStrategy(); } else { lockStrategy = new NoLockStrategy(); } }
public void DoubleWriteLockThrows() { using (ILockStrategy strategy = GetLockStrategy()) { using (var writeLock1 = strategy.GetWriteLock()) { using (var writeLock2 = strategy.GetWriteLock()) { //do nothing } } } }
public void TestThreadedTryWrite() { using (ILockStrategy l = LockFactory.Create()) { Assert.IsTrue(l.TryWrite(0)); l.ReleaseWrite(); using (new ThreadedWriter(l)) Assert.IsFalse(l.TryWrite(0)); Assert.IsTrue(l.TryWrite(0)); l.ReleaseWrite(); } }
// IDisposable protected virtual void Dispose(bool disposing) { if (!_isDisposed) { if (disposing) { // dispose managed state (managed objects). } _lockStrategy.Dispose(); _lockStrategy = null; } _isDisposed = true; }
public ContentState(ContentStorage content) { //_executionLock = new SimpleReadWriteLocking(); _executionLock = IgnoreLocking.Instance; _rsaKeyPair = ReadKeyFile(); _content = content ?? ReadCurrent(); _channel = new IpcEventChannel(Path.Combine(Settings.RegistryPath, "IISChannel"), BitConverter.ToString(Hash.MD5(Encoding.UTF8.GetBytes(StoragePath)).ToArray())); _channel.OnError += (o, e) => Log.Error(e.GetException()); _channel[Events.ContentUpdate].OnEvent += OnContentUpdated; _channel[Events.CompletionAck].OnEvent += (o, e) => { }; _channel.StartListening(); }
public ThreadedWriter(ILockStrategy lck) { _started = new ManualResetEvent(false); _complete = new ManualResetEvent(false); _lck = lck; _delegate = HoldLock; _async = _delegate.BeginInvoke(null, null); if (!_started.WaitOne(1000, false)) { _delegate.EndInvoke(_async); Assert.Fail("Unable to acquire lock"); } Assert.IsTrue(_locked); }
public override void ResetCache() { _keepAlive.Clear(); _cache.Clear(); _cacheLock = new ReaderWriterLocking(); _root = GetCache(_root.Handle, true); bool isnew; Assert(_root.Handle.StoreHandle.Equals(Storage.OpenRoot(out isnew))); if (isnew) { _root.Node = CreateRoot(_root.Handle); } }
public TextQueue(string queueFile, bool synchronized) { Stream output = new FileStream(queueFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read); output.Seek(0, SeekOrigin.End); _write = new StreamWriter(output, Encoding.UTF8); Stream input = new FileStream(queueFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); _read = new StreamReader(input, Encoding.UTF8); if (synchronized) { _writeLock = new SimpleReadWriteLocking(); _readLock = new ExclusiveLocking(); } else { _writeLock = _readLock = IgnoreLocking.Instance; } }
public ThreadedReader(ILockStrategy lck) : base(lck) { }
/// <summary> Tracks an existing read lock on a resource </summary> public ReadLock(ILockStrategy lck, bool locked) { _lock = lck; _hasLock = locked; }
public ThreadSafeWorkingMemory(bool supportHotSwap) { if (supportHotSwap) lockStrategy = new ReaderWriterLockStrategy(); else lockStrategy = new NoLockStrategy(); }
/// <summary> Tracks an existing read lock on a resource </summary> public WriteLock(ILockStrategy lck, bool locked) { _lock = lck; _hasLock = locked; }
/// <summary> Acquires a read lock on the resource </summary> public WriteLock(ILockStrategy lck, int timeout) { _lock = lck; _hasLock = lck.TryWrite(timeout); }
/// <summary> Acquires a read lock on the resource </summary> public ReadLock(ILockStrategy lck, int timeout) { _lock = lck; _hasLock = lck.TryRead(timeout); }
/// <summary> Acquires the lock within the timeout or throws TimeoutException </summary> /// <exception cref="System.TimeoutException"/> public static WriteLock Acquire(ILockStrategy lck, int timeout) { if(!lck.TryWrite(timeout)) throw new TimeoutException(); return new WriteLock(lck, true); }