public async Task <ILock> LockAsync(string ck, int ttl = 5000, int retry = 2, int retryDelay = 1000) { var lck = new Lock(this, ck, ttl); retry = retry < 0 ? 0 : retry; for (var i = 0; i <= retry; i++) { var tmp = kvs.GetOrAdd(ck, lck); if (!tmp.IsAvailable) { tmp.Dispose(); i--; } else if (!ReferenceEquals(tmp, lck)) { await Task.Delay(retryDelay).ConfigureAwait(false); } else { lck.SetTimeout(); return(lck); } } lck.Dispose(); return(lck); }
protected override void Dispose(bool disposing) { if (disposing) { DelegateLock.Dispose(); OuterInstance.Dir.OpenLocks.Remove(Name); } }
protected override void Dispose(bool disposing) { if (disposing) { delegateLock.Dispose(); outerInstance.dir.openLocks.Remove(name); } }
public void Dispose() { if (_lockHandle != null && _lockHandle.LockTaken) { _lockHandle.Dispose(); _repository._isFileSystemWatcherSuppressed = false; } }
/// <summary> /// Sends contending to the remote storage if the item is modified. /// If Auto-locking is enabled, automatically locks the file if not locked. Unlocks the file after the update if auto-locked. /// </summary> public async Task UpdateAsync() { Lock fileLock = null; try { if (!PlaceholderItem.GetItem(userFileSystemPath).GetInSync()) { // Lock file if auto-locking is enabled. if (Config.Settings.AutoLock) { // Get existing lock or create a new lock. fileLock = await LockAsync(FileMode.OpenOrCreate, LockMode.Auto); } ServerLockInfo lockInfo = fileLock != null ? await fileLock.GetLockInfoAsync() : null; // Update item in remote storage. logger.LogMessage("Sending to remote storage", userFileSystemPath); await CreateOrUpdateAsync(FileMode.Open, lockInfo); //await new UserFileSystemRawItem(userFileSystemPath).ClearStateAsync(); logger.LogMessage("Sent to remote storage succesefully", userFileSystemPath); } // Unlock if auto-locked. if (await Lock.GetLockModeAsync(userFileSystemPath) == LockMode.Auto) { if (fileLock == null) { // Get existing lock. fileLock = await Lock.LockAsync(userFileSystemPath, FileMode.Open, LockMode.None, logger); } await UnlockAsync(fileLock); } } catch (ClientLockFailedException ex) { // Failed to lock file. Possibly blocked from another thread. This is a normal behaviour. logger.LogMessage(ex.Message, userFileSystemPath); } catch (Exception ex) { // Some error when locking, updating or unlocking occured. await new UserFileSystemRawItem(userFileSystemPath).SetUploadErrorStateAsync(ex); // Rethrow the exception preserving stack trace of the original exception. System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw(); } finally { if (fileLock != null) { fileLock.Dispose(); } } }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { Lock?.Dispose(); Lock = null; Timer?.Dispose(); Timer = null; } disposedValue = true; } }
protected virtual async ValueTask DisposeAsync(bool disposing) { await _taskTimerLock.TryLockAsync( () => { if (_taskTimer != null) { _taskTimer.Dispose(); _taskTimer = null; } }, 5000); _taskTimerLock.Dispose(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { try { if (disposing) { if (!_isDisposed) { bool disposeLock = false; ComposablePartCatalogCollection?catalogs = null; try { using (new WriteLock(_thisLock)) { if (!_isDisposed) { disposeLock = true; catalogs = _catalogCollection; _catalogCollection = null !; _assemblyCatalogs = null !; _isDisposed = true; } } } finally { if (catalogs != null) { catalogs.Dispose(); } if (disposeLock) { _thisLock.Dispose(); } } } } } finally { base.Dispose(disposing); } }
protected virtual void Dispose(bool disposing) { if (Disposed) { return; } Disposed = true; if (!disposing) { return; } Writer.Flush(); Writer.Close(); Writer.Dispose(); Lock.Dispose(); }
private void Dispose(bool disposing) { if (disposing) { if (!_isDisposed) { bool disposeLock = false; IEnumerable <ComposablePartCatalog>?catalogs = null; try { using (new WriteLock(_lock)) { if (!_isDisposed) { disposeLock = true; catalogs = _catalogs; _catalogs = null !; _isDisposed = true; } } } finally { if (catalogs != null) { UnsubscribeFromCatalogNotifications(catalogs); catalogs.ForEach(catalog => catalog.Dispose()); } if (disposeLock) { _lock.Dispose(); } } } } }
public async ValueTask DisposeAsync() { try { await StopWorkerAsync().ConfigureAwait(false); } catch (Exception ex) { // Don't throw inside dispose _options.DiagnosticLogger?.LogError( "Error stopping worker during dispose.", ex ); } _workerSignal.Dispose(); _workerCts.Dispose(); _worker.Dispose(); _cacheDirectoryLock.Dispose(); (_innerTransport as IDisposable)?.Dispose(); }
protected override void Dispose(bool disposing) { try { if (disposing) { Lock disposeLock = null; if (!this._isDisposed) { using (new WriteLock(this._lock)) { if (!this._isDisposed) { this._isDisposed = true; disposeLock = this._lock; this._lock = null; this._packages = null; this._loadedAssemblies = null; this._parts = null; this._partsQuery = null; } } } if (disposeLock != null) { disposeLock.Dispose(); } } } finally { base.Dispose(disposing); } }
public void Dispose() { Lock.Dispose(); }
public void Dispose() { Lock.Dispose(); Lock = null; ObjectRenewalLogic = null; }
/// <summary> /// 释放锁节点 /// </summary> /// <returns></returns> internal override Node RunTask() { Lock.Dispose(); return(LinkNext); }
/// <summary> /// 释放锁节点 /// </summary> public override void RunTask() { Lock.Dispose(); }
/// <summary> /// 释放锁 /// </summary> public void Dispose() { _lock.Dispose(); }