/// <summary>
/// Gets a value indicating whether the image is new or updated in an asynchronous manner.
/// </summary>
/// <returns>
/// The asynchronous <see cref="Task"/> returning the value.
/// </returns>
public override async Task <bool> IsNewOrUpdatedAsync()
{
string cachedFileName = await this.CreateCachedFileNameAsync();
// Collision rate of about 1 in 10000 for the folder structure.
// That gives us massive scope to store millions of files.
string pathFromKey = string.Join("\\", cachedFileName.ToCharArray().Take(6));
this.CachedPath = Path.Combine(this.cloudCachedBlobContainer.Uri.ToString(), pathFromKey, cachedFileName).Replace(@"\", "/");
this.cachedRewritePath = Path.Combine(this.cachedCdnRoot, this.cloudCachedBlobContainer.Name, pathFromKey, cachedFileName).Replace(@"\", "/");
bool isUpdated = false;
CachedImage cachedImage = CacheIndexer.Get(this.CachedPath);
if (new Uri(this.CachedPath).IsFile)
{
FileInfo fileInfo = new FileInfo(this.CachedPath);
if (fileInfo.Exists)
{
// Pull the latest info.
fileInfo.Refresh();
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = fileInfo.CreationTimeUtc
};
CacheIndexer.Add(cachedImage);
}
}
if (cachedImage == null)
{
string blobPath = this.CachedPath.Substring(this.cloudCachedBlobContainer.Uri.ToString().Length + 1);
CloudBlockBlob blockBlob = this.cloudCachedBlobContainer.GetBlockBlobReference(blobPath);
if (await blockBlob.ExistsAsync())
{
// Pull the latest info.
await blockBlob.FetchAttributesAsync();
if (blockBlob.Properties.LastModified.HasValue)
{
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = blockBlob.Properties.LastModified.Value.UtcDateTime
};
CacheIndexer.Add(cachedImage);
}
}
}
if (cachedImage == null)
{
// Nothing in the cache so we should return true.
isUpdated = true;
}
else
{
// Check to see if the cached image is set to expire.
if (this.IsExpired(cachedImage.CreationTimeUtc))
{
CacheIndexer.Remove(this.CachedPath);
isUpdated = true;
}
}
return(isUpdated);
}
/// <summary>
/// Gets a value indicating whether the image is new or updated in an asynchronous manner.
/// </summary>
/// <returns>
/// The asynchronous <see cref="Task"/> returning the value.
/// </returns>
public override async Task <bool> IsNewOrUpdatedAsync()
{
// TODO: Before this check is performed it should be throttled. For example, only perform this check
// if the last time it was checked is greater than 5 seconds. This would be much better for perf
// if there is a high throughput of image requests.
string cachedFileName = await this.CreateCachedFileNameAsync().ConfigureAwait(false);
this.CachedPath = CachedImageHelper.GetCachedPath(cloudCachedBlobContainer.Uri.ToString(), cachedFileName, true, this.FolderDepth);
this.cachedRewritePath = CachedImageHelper.GetCachedPath(useCachedContainerInUrl
? Path.Combine(cachedCdnRoot, cloudCachedBlobContainer.Name)
: cachedCdnRoot, cachedFileName, true, this.FolderDepth);
bool isUpdated = false;
CachedImage cachedImage = CacheIndexer.Get(this.CachedPath);
if (new Uri(this.CachedPath).IsFile&& File.Exists(this.CachedPath))
{
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = File.GetCreationTimeUtc(this.CachedPath)
};
CacheIndexer.Add(cachedImage, this.ImageCacheMaxMinutes);
}
if (cachedImage is null)
{
string blobPath = this.CachedPath.Substring(cloudCachedBlobContainer.Uri.ToString().Length + 1);
CloudBlockBlob blockBlob = cloudCachedBlobContainer.GetBlockBlobReference(blobPath);
if (await blockBlob.ExistsAsync().ConfigureAwait(false))
{
// Pull the latest info.
await blockBlob.FetchAttributesAsync().ConfigureAwait(false);
if (blockBlob.Properties.LastModified.HasValue)
{
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = blockBlob.Properties.LastModified.Value.UtcDateTime
};
CacheIndexer.Add(cachedImage, this.ImageCacheMaxMinutes);
}
}
}
if (cachedImage is null)
{
// Nothing in the cache so we should return true.
isUpdated = true;
}
else
{
// Check to see if the cached image is set to expire
// or a new file with the same name has replaced our current image
if (this.IsExpired(cachedImage.CreationTimeUtc) || await this.IsUpdatedAsync(cachedImage.CreationTimeUtc).ConfigureAwait(false))
{
CacheIndexer.Remove(this.CachedPath);
isUpdated = true;
}
}
return(isUpdated);
}
/// <summary>
/// Gets a value indicating whether the image is new or updated in an asynchronous manner.
/// </summary>
/// <returns>
/// The asynchronous <see cref="Task"/> returning the value.
/// </returns>
public override async Task <bool> IsNewOrUpdatedAsync()
{
string cachedFileName = await this.CreateCachedFileNameAsync();
// Collision rate of about 1 in 10000 for the folder structure.
// That gives us massive scope to store millions of files.
string pathFromKey = string.Join("\\", cachedFileName.ToCharArray().Take(6));
this.CachedPath = Path.Combine(this.cachedCdnRoot, this.imageProcessorCachePrefix, pathFromKey, cachedFileName)
.Replace(@"\", "/");
bool isUpdated = false;
CachedImage cachedImage = CacheIndexer.Get(this.CachedPath);
if (new Uri(this.CachedPath).IsFile)
{
FileInfo fileInfo = new FileInfo(this.CachedPath);
if (fileInfo.Exists)
{
// Pull the latest info.
fileInfo.Refresh();
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = fileInfo.CreationTimeUtc
};
CacheIndexer.Add(cachedImage);
}
}
if (cachedImage == null)
{
try
{
string path = this.GetFolderStructureForAmazon(this.CachedPath);
string filename = Path.GetFileName(this.CachedPath);
string key = this.GetKey(path, filename);
GetObjectMetadataRequest objectMetaDataRequest = new GetObjectMetadataRequest
{
BucketName = this.awsBucketName,
Key = key,
};
GetObjectMetadataResponse response = await this.amazonS3ClientCache.GetObjectMetadataAsync(objectMetaDataRequest);
if (response != null)
{
cachedImage = new CachedImage
{
Key = key,
Path = this.CachedPath,
CreationTimeUtc = response.LastModified.ToUniversalTime()
};
CacheIndexer.Add(cachedImage);
}
}
catch (AmazonS3Exception)
{
// Nothing in S3 so we should return true.
isUpdated = true;
}
}
if (cachedImage == null)
{
// Nothing in the cache so we should return true.
isUpdated = true;
}
else
{
// Check to see if the cached image is set to expire.
if (this.IsExpired(cachedImage.CreationTimeUtc))
{
CacheIndexer.Remove(this.CachedPath);
isUpdated = true;
}
}
return(isUpdated);
}
/// <summary>
/// Gets a value indicating whether the image is new or updated in an asynchronous manner.
/// </summary>
/// <returns>
/// The asynchronous <see cref="Task"/> returning the value.
/// </returns>
public override async Task <bool> IsNewOrUpdatedAsync()
{
// TODO: Before this check is performed it should be throttled. For example, only perform this check
// if the last time it was checked is greater than 5 seconds. This would be much better for perf
// if there is a high throughput of image requests.
string cachedFileName = await this.CreateCachedFileNameAsync().ConfigureAwait(false);
// Collision rate of about 1 in 10000 for the folder structure.
// That gives us massive scope to store millions of files.
string pathFromKey = string.Join("\\", cachedFileName.ToCharArray().Take(6));
this.CachedPath = Path.Combine(cachedCdnRoot, awsCacheKeyPrefix, pathFromKey, cachedFileName)
.Replace(@"\", "/");
this.cachedRewritePath = this.CachedPath;
bool isUpdated = false;
CachedImage cachedImage = CacheIndexer.Get(this.CachedPath);
if (new Uri(this.CachedPath).IsFile)
{
var fileInfo = new FileInfo(this.CachedPath);
if (fileInfo.Exists)
{
// Pull the latest info.
fileInfo.Refresh();
cachedImage = new CachedImage
{
Key = Path.GetFileNameWithoutExtension(this.CachedPath),
Path = this.CachedPath,
CreationTimeUtc = fileInfo.CreationTimeUtc
};
CacheIndexer.Add(cachedImage, this.ImageCacheMaxMinutes);
}
}
if (cachedImage == null)
{
try
{
string path = this.GetFolderStructureForAmazon(this.CachedPath);
string filename = Path.GetFileName(this.CachedPath);
string key = this.GetKey(path, filename);
var objectMetaDataRequest = new GetObjectMetadataRequest
{
BucketName = awsBucketName,
Key = key,
};
GetObjectMetadataResponse response = await amazonS3ClientCache.GetObjectMetadataAsync(objectMetaDataRequest).ConfigureAwait(false);
if (response != null)
{
cachedImage = new CachedImage
{
Key = key,
Path = this.CachedPath,
CreationTimeUtc = response.LastModified.ToUniversalTime()
};
CacheIndexer.Add(cachedImage, this.ImageCacheMaxMinutes);
}
}
catch (AmazonS3Exception)
{
// Nothing in S3 so we should return true.
isUpdated = true;
}
}
if (cachedImage == null)
{
// Nothing in the cache so we should return true.
isUpdated = true;
}
else
{
// Check to see if the cached image is set to expire
// or a new file with the same name has replaced our current image
if (this.IsExpired(cachedImage.CreationTimeUtc) || await this.IsUpdatedAsync(cachedImage.CreationTimeUtc).ConfigureAwait(false))
{
CacheIndexer.Remove(this.CachedPath);
isUpdated = true;
}
}
return(isUpdated);
}
