public static void AsyncLock_Acquire_Timeout()
{
using (var l = new AsyncLock())
{
var sw = Stopwatch.StartNew();
using (AsyncLockCookie t1 = l.Acquire())
using (AsyncLockCookie t2 = l.Acquire(100))
{
Assert.True(t1.IsAcquired);
Assert.False(t2.IsAcquired);
Assert.True(sw.Elapsed.TotalMilliseconds >= 80);
}
}
}
public static void AsyncLock_Acquire_Twice()
{
using (var l = new AsyncLock())
{
using (AsyncLockCookie t = l.Acquire())
{
Assert.True(t.IsAcquired);
Assert.Equal(t.IsAcquired, t);
}
using (AsyncLockCookie t = l.Acquire())
{
Assert.True(t.IsAcquired);
}
}
}
public async Task <T> GetAsync <T>(string key, Func <Task <T> > acquirer, TimeSpan?duration = null)
{
T value;
if (TryGet(key, out value))
{
return(value);
}
// get the async (semaphore) locker specific to this key
var keyLock = AsyncLock.Acquire(key);
using (await keyLock.LockAsync())
{
if (!TryGet(key, out value))
{
value = await acquirer().ConfigureAwait(false);
Put(key, value, duration);
return(value);
}
}
return(value);
}
public override async ValueTask <T> ReadAsync(CancellationToken token)
{
await reader.WaitToReadAsync(token).ConfigureAwait(false);
//lock and deserialize
T result;
using (await readLock.Acquire(token).ConfigureAwait(false))
{
var lookup = Partition;
//reset file cache
await lookup.FlushAsync(token).ConfigureAwait(false);
result = await reader.DeserializeAsync(lookup, token).ConfigureAwait(false);
cursor.Advance(lookup.Position);
}
return(result);
}
public override async ValueTask WriteAsync(T item, CancellationToken token)
{
using (await writeLock.Acquire(token).ConfigureAwait(false))
{
var partition = Partition;
await writer.SerializeAsync(item, partition, token).ConfigureAwait(false);
cursor.Advance(partition.Position);
}
writer.MessageReady();
}
public static void AsyncLock_Acquire_Wait()
{
using (var l = new AsyncLock())
{
AsyncLockCookie t1 = l.Acquire();
Assert.True(t1.IsAcquired);
var sw = Stopwatch.StartNew();
ThreadPool.QueueUserWorkItem(_ =>
{
Thread.Sleep(500);
t1.Dispose();
});
using (AsyncLockCookie t2 = l.Acquire())
{
Assert.True(t2);
}
Assert.True(sw.Elapsed.TotalMilliseconds >= 400);
}
}
public static void AsyncLock_Acquire_Fail()
{
using (var l = new AsyncLock())
{
using (AsyncLockCookie t1 = l.Acquire())
{
Assert.True(t1.IsAcquired);
using (AsyncLockCookie t2 = l.Acquire(0))
{
Assert.False(t2.IsAcquired);
Assert.Equal(t2.IsAcquired, t2);
}
using (AsyncLockCookie t2 = l.Acquire(TimeSpan.Zero))
{
Assert.False(t2.IsAcquired);
Assert.Equal(t2.IsAcquired, t2);
}
}
}
}
public async Task <ulong> GetFileSizeInBytes()
{
if (_fileSizeInBytes == null)
{
using (await bsf_lock.Acquire())
{
var props = await _backingFile.GetBasicPropertiesAsync();
_fileSizeInBytes = props.Size;
}
}
return(_fileSizeInBytes.Value);
}
public IExchange DeclareExchange(string exchangeName, string exchangeType)
{
if (exchanges.TryGetValue(exchangeName, out var exchange))
{
return(exchange);
}
using (asyncLock.Acquire())
{
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return(exchange);
}
exchange = advancedBus.ExchangeDeclare(exchangeName, exchangeType);
exchanges[exchangeName] = exchange;
return(exchange);
}
}
public async Task StopRoamingFile(IBindableStorageFile file)
{
using (await f_lock.Acquire())
{
if (!LocalFiles.Contains(file))
{
//Backing values
string oldPath = GetParentFolder(file.BackingFile);
string value = await _ivService.GetValue(oldPath, FileLocation.Roamed);
await _ivService.Remove(oldPath, FileLocation.Roamed);
await file.BackingFile.MoveAsync(_localFolder, file.BackingFile.Name, NameCollisionOption.GenerateUniqueName);
await _ivService.Add(GetParentFolder(file.BackingFile), value, FileLocation.Local);
RoamedFiles.Remove(file);
//UI
file.IsRoamed = false;
LocalFiles.Add(file);
}
}
}
private async Task <ActionResult> HandleImage(
ProcessImageQuery query,
CachedImageResult cachedImage,
string nameWithoutExtension,
string mime,
string extension,
Func <string, Task <byte[]> > getSourceBuffer)
{
string prevMime = null;
if (extension != cachedImage.Extension)
{
// The query requests another format.
// Adjust extension and mime type fo proper ETag creation.
extension = cachedImage.Extension;
prevMime = mime;
mime = MimeTypes.MapNameToMimeType(cachedImage.FileName);
}
if (cachedImage.Exists)
{
if (ETagMatches(nameWithoutExtension, mime, cachedImage.LastModifiedUtc.Value))
{
return(Content(null));
}
}
var isFaulted = false;
try
{
if (!cachedImage.Exists)
{
// get the async (semaphore) locker specific to this key
var keyLock = AsyncLock.Acquire("lock" + cachedImage.Path);
// Lock concurrent requests to same resource
using (await keyLock.LockAsync())
{
_imageCache.RefreshInfo(cachedImage);
// File could have been processed by another request in the meantime, check again.
if (!cachedImage.Exists)
{
// Call inner function
byte[] source = await getSourceBuffer(prevMime);
if (source == null)
{
return(NotFound(mime));
}
source = await ProcessAndPutToCacheAsync(cachedImage, source, query);
return(File(source, mime));
}
}
}
if (Request.HttpMethod == "HEAD")
{
return(new HttpStatusCodeResult(200));
}
if (cachedImage.IsRemote && !_streamRemoteMedia)
{
// Redirect to existing remote file
Response.ContentType = mime;
return(Redirect(_imageCache.GetPublicUrl(cachedImage.Path)));
}
else
{
// Open existing stream
return(File(cachedImage.File.OpenRead(), mime));
}
}
catch (Exception ex)
{
isFaulted = true;
if (!(ex is ProcessImageException))
{
// ProcessImageException is logged already in ImageProcessor
Logger.ErrorFormat(ex, "Error processing media file '{0}'.", cachedImage.Path);
}
return(new HttpStatusCodeResult(500, ex.Message));
}
finally
{
if (!isFaulted)
{
FinalizeRequest(nameWithoutExtension, mime, cachedImage.LastModifiedUtc.GetValueOrDefault());
}
}
}