public ParalleLockTest() { _taskLock = new TaskLock(); _lockObject = new object(); _count = 0; _n = 0; }
public async Task GetLockTest4Async() { TaskLock lockQueue = new TaskLock(maxQueueSize: 1); var startTcs = new TaskCompletionSource <bool>(); var stopTcs = new TaskCompletionSource <bool>(); _ = Task.Run(async() => { using (await lockQueue.GetLock(CancellationToken.None)) { startTcs.TrySetResult(true); await stopTcs.Task; } }); try { await startTcs.Task; using (await lockQueue.GetLock(CancellationToken.None)) { Assert.Fail(); // We should not get here! } } catch (Exception ex) { ex.ShouldBeOfType <IndexOutOfRangeException>(); } stopTcs.SetResult(true); }
public async Task GetLockTest3Async() { TaskLock lockQueue = new TaskLock(maxQueueSize: 100); var startTcs = new TaskCompletionSource <bool>(); var stopTcs = new TaskCompletionSource <bool>(); _ = Task.Run(async() => { using (await lockQueue.GetLock(CancellationToken.None)) { startTcs.TrySetResult(true); await stopTcs.Task; } }); try { await startTcs.Task; using (await lockQueue.GetLock(CancellationToken.None, TimeSpan.FromMilliseconds(1))) { Assert.Fail(); // We should not get here! } } catch (Exception ex) { ex.ShouldBeOfType <TaskCanceledException>(); } stopTcs.TrySetResult(true); }
public bool LockOperation(ulong taskId, int state) { TaskLock tlock = null; if (!locks.TryGetValue(taskId, out tlock)) { tlock = new TaskLock { State = state, Time = DateTime.Now }; if (!locks.TryAdd(taskId, tlock)) { if (state != TaskLock.WRITE_OPERATION_EXECUTED) { if (locks.TryGetValue(taskId, out tlock)) { if (tlock.State != TaskLock.WRITE_OPERATION_EXECUTED) { return(TaskLock.LOCK_READER); } } } throw new Exception("Some WRITE operation currently is being executed."); } return(TaskLock.LOCK_HOLDER); } if (tlock.State != TaskLock.WRITE_OPERATION_EXECUTED && state != TaskLock.WRITE_OPERATION_EXECUTED) { return(TaskLock.LOCK_READER); } throw new Exception("Some WRITE operation currently is being executed."); }
public void UnLockOperation(ulong taskId, bool lockHolder) { TaskLock tlock = null; if (lockHolder && locks.TryGetValue(taskId, out tlock) && tlock.State != TaskLock.NO_OPERATION_EXECUTED) { tlock.State = TaskLock.NO_OPERATION_EXECUTED; } else { throw new Exception(String.Format("State of the task {0} operations on the controller is in inconsistency", taskId)); } }
public async Task LockedTimeout() { using (var x = new TaskLock()) { using (await x.Enter()) { var start = DateTime.UtcNow; try { using (await x.Enter(2000)) { Assert.Fail(); } } catch (TimeoutException) { var time = (DateTime.UtcNow - start).Ticks; Assert.IsTrue((TimeSpan.TicksPerMillisecond * 1900) <= time && time <= (TimeSpan.TicksPerMillisecond * 2100)); } } } }
public async Task GetLockTestAsync() { TaskLock lockQueue = new TaskLock(maxQueueSize: 100); var task1 = Task.Run(async() => { using (await lockQueue.GetLock(CancellationToken.None)) { await TaskDelay.TryDelay(2, CancellationToken.None); } }); using (await lockQueue.GetLock(CancellationToken.None)) { await TaskDelay.TryDelay(2, CancellationToken.None); } await task1; }
public async Task LockedCancellation() { using (var x = new TaskLock()) { using (await x.Enter()) { var start = DateTime.UtcNow; try { using (var cts = new CancellationTokenSource(2000)) { using (await x.Enter(cts.Token)) { Assert.Fail(); } } } catch (OperationCanceledException) { var time = (DateTime.UtcNow - start).Ticks; Assert.IsTrue((TimeSpan.TicksPerMillisecond * 1900) <= time && time <= (TimeSpan.TicksPerMillisecond * 2100)); } } } }
public async Task GetLockTest2Async() { TaskLock lockQueue = new TaskLock(maxQueueSize: 100); var startTcs = new TaskCompletionSource <bool>(); var stopTcs = new TaskCompletionSource <bool>(); var task1 = Task.Run(async() => { using (await lockQueue.GetLock(CancellationToken.None)) { startTcs.TrySetResult(true); await stopTcs.Task; } }); try { await startTcs.Task; using var preCts = new CancellationTokenSource(); preCts.Cancel(); using (await lockQueue.GetLock(preCts.Token)) { Assert.Fail(); // We should not get here! } } catch (Exception ex) { ex.ShouldBeOfType <TaskCanceledException>(); } stopTcs.TrySetResult(true); using (await lockQueue.GetLock(CancellationToken.None)) { } await task1; }
public async Task ConnectAsync() { // Init lock (this) { if (_state != ConnectionState.Closed) { throw new SMPPException("SMPPConnection busy."); } _tcpClient = new TcpClient(); _sendLock = new TaskLock(); _error = null; _sequence = 1; } Exception error = null; // Connect to SMPP server try { Stream stream; using (new System.Threading.Timer((object state) => { lock (this) { if (_state == ConnectionState.Connecting || _state == ConnectionState.SslHandshake) { error = new TimeoutException("Timeout"); _tcpClient.Close(); } } }, null, 15 * 1000, System.Threading.Timeout.Infinite)) { _setState(ConnectionState.Connecting); await _tcpClient.ConnectAsync(Hostname, Port); stream = _tcpClient.GetStream(); if (Tls) { _setState(ConnectionState.SslHandshake); SslStream sslStream = new SslStream(stream, true); await sslStream.AuthenticateAsClientAsync(Hostname); stream = sslStream; } } lock (this) { if (error != null) { throw error; } _setState(ConnectionState.StreamConnected); _stream = stream; } } catch (Exception err) { if (err is ObjectDisposedException || err is NullReferenceException) { lock (this) { if (error != null) { err = error; } else if (_state == ConnectionState.Closed) { err = new SMPPException("Connect aborted by close."); } } } err = _setFailed(new SMPPException("Connect failed.", err)); Close(); throw err; } // Start comtask Task _ = _run(); // Bind try { _setState(ConnectionState.Binding); SMPPMessage response = await _submitMessage(Bind); if (response.Status != CommandStatus.ESME_ROK) { throw new SMPPException("Response from server " + response.Status + "."); } _setState(ConnectionState.Connected); _enquirePoll = EnquirePoll; } catch (Exception err) { throw _setFailed(new SMPPException("Bind failed", err)); } }