public virtual async Task <bool> IsUpToDateAsync(ISet <string> spaces, long timestamp /* H2.1 has Long here */, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _isUpToDate.LockAsync()) { if (_batchReadOnlyUpdateTimestamps != null) { if (spaces.Count == 0) { return(true); } var keys = new object[spaces.Count]; var index = 0; foreach (var space in spaces) { keys[index++] = space; } var lastUpdates = await(_batchReadOnlyUpdateTimestamps.GetManyAsync(keys, cancellationToken)).ConfigureAwait(false); return(lastUpdates.All(lastUpdate => !IsOutdated(lastUpdate as long?, timestamp))); } return(spaces.Select(space => updateTimestamps.Get(space)) .All(lastUpdate => !IsOutdated(lastUpdate as long?, timestamp))); } }
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { if (_lastSourceValue < 0) { _lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); while (_lastSourceValue <= 0) { _lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); } // upperLimit defines the upper end of the bucket values _upperLimit = (_lastSourceValue * IncrementSize) + 1; // initialize value to the low end of the bucket _value = _upperLimit - IncrementSize; } else if (_upperLimit <= _value) { _lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); _upperLimit = (_lastSourceValue * IncrementSize) + 1; } return(Make(_value++)); } }
public override async Task <object> GenerateAsync(ISessionImplementor session, object obj, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { if (maxLo < 1) { //keep the behavior consistent even for boundary usages long val = Convert.ToInt64(await(base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); if (val == 0) { val = Convert.ToInt64(await(base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); } return(IdentifierGeneratorFactory.CreateNumber(val, returnClass)); } if (lo > maxLo) { long hival = Convert.ToInt64(await(base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); lo = (hival == 0) ? 1 : 0; hi = hival * (maxLo + 1); if (log.IsDebugEnabled) { log.Debug("new hi value: " + hival); } } return(IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass)); } }
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { if (_hiValue < 0) { _value = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); if (_value < 1) { // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... Log.Info("pooled optimizer source reported [" + _value + "] as the initial value; use of 1 or greater highly recommended"); } if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue) { _hiValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); } else { _hiValue = _value; _value = _hiValue - IncrementSize; } } else if (_value >= _hiValue) { _hiValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); _value = _hiValue - IncrementSize; } return(Make(_value++)); } }
public virtual async Task <object> GenerateAsync(ISessionImplementor session, object obj, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { return(await(Optimizer.GenerateAsync(new TableAccessCallback(session, this), cancellationToken)).ConfigureAwait(false)); } }
public virtual async Task <bool[]> AreUpToDateAsync(ISet <string>[] spaces, long[] timestamps, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _areUpToDate.LockAsync()) { var results = new bool[spaces.Length]; var allSpaces = new HashSet <string>(); foreach (var sp in spaces) { allSpaces.UnionWith(sp); } if (_batchReadOnlyUpdateTimestamps != null) { if (allSpaces.Count == 0) { for (var i = 0; i < spaces.Length; i++) { results[i] = true; } return(results); } var keys = new object[allSpaces.Count]; var index = 0; foreach (var space in allSpaces) { keys[index++] = space; } index = 0; var lastUpdatesBySpace = (await(_batchReadOnlyUpdateTimestamps .GetManyAsync(keys, cancellationToken)).ConfigureAwait(false)) .ToDictionary(u => keys[index++], u => u as long?); for (var i = 0; i < spaces.Length; i++) { var timestamp = timestamps[i]; results[i] = spaces[i].All(space => !IsOutdated(lastUpdatesBySpace[space], timestamp)); } } else { for (var i = 0; i < spaces.Length; i++) { results[i] = await(IsUpToDateAsync(spaces[i], timestamps[i], cancellationToken)).ConfigureAwait(false); } } return(results); } }
public virtual async Task <object> GenerateAsync(ISessionImplementor session, object obj, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { // This has to be done using a different connection to the containing // transaction becase the new hi value must remain valid even if the // containing transaction rolls back. return(await(DoWorkInNewTransactionAsync(session, cancellationToken)).ConfigureAwait(false)); } }
public virtual async Task PreInvalidateAsync(IReadOnlyCollection <string> spaces, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _preInvalidate.LockAsync()) { //TODO: to handle concurrent writes correctly, this should return a Lock to the client var ts = updateTimestamps.NextTimestamp() + updateTimestamps.Timeout; await(SetSpacesTimestampAsync(spaces, ts, cancellationToken)).ConfigureAwait(false); //TODO: return new Lock(ts); } //TODO: return new Lock(ts); }
public virtual async Task <bool> IsUpToDateAsync(ISet <string> spaces, long timestamp /* H2.1 has Long here */, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _isUpToDate.LockAsync()) { if (spaces.Count == 0) { return(true); } var lastUpdates = await(_updateTimestamps.GetManyAsync(spaces.ToArray <object>(), cancellationToken)).ConfigureAwait(false); return(lastUpdates.All(lastUpdate => !IsOutdated(lastUpdate as long?, timestamp))); } }
public virtual async Task InvalidateAsync(IReadOnlyCollection <string> spaces, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _invalidate.LockAsync()) { //TODO: to handle concurrent writes correctly, the client should pass in a Lock long ts = updateTimestamps.NextTimestamp(); //TODO: if lock.getTimestamp().equals(ts) if (log.IsDebugEnabled()) { log.Debug("Invalidating spaces [{0}]", StringHelper.CollectionToString(spaces)); } await(SetSpacesTimestampAsync(spaces, ts, cancellationToken)).ConfigureAwait(false); } }
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _generate.LockAsync()) { if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize)) { _lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); _value = _lastSourceValue; // handle cases where initial-value is less than one (hsqldb for instance). while (_value < 1) { _value++; } } return(Make(_value++)); } }
public virtual async Task <bool[]> AreUpToDateAsync(ISet <string>[] spaces, long[] timestamps, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); using (await _areUpToDate.LockAsync()) { if (spaces.Length == 0) { return(Array.Empty <bool>()); } var allSpaces = new HashSet <string>(); foreach (var sp in spaces) { allSpaces.UnionWith(sp); } if (allSpaces.Count == 0) { return(ArrayHelper.Fill(true, spaces.Length)); } var keys = allSpaces.ToArray <object>(); var index = 0; var lastUpdatesBySpace = (await(_updateTimestamps .GetManyAsync(keys, cancellationToken)).ConfigureAwait(false)) .ToDictionary(u => keys[index++], u => u as long?); var results = new bool[spaces.Length]; for (var i = 0; i < spaces.Length; i++) { var timestamp = timestamps[i]; results[i] = spaces[i].All(space => !IsOutdated(lastUpdatesBySpace[space], timestamp)); } return(results); } }