public static Exception ConditionFailed(IStreamingItem item, StreamingCondition condition, Exception inner = null)
{
var message = string.Format(CultureInfo.InvariantCulture, "Storage condition '{0}' failed for '{1}'",
condition,
item.FullPath);
return new StreamingConditionFailedException(message, inner);
}
//const string ContentCompression = "gzip";
/// <summary>
/// Performs the write operation, ensuring that the condition is met.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="condition">The condition.</param>
/// <param name="writeOptions">The write options.</param>
public long Write(Action <Stream> writer, StreamingCondition condition, StreamingWriteOptions writeOptions)
{
try
{
var mapped = Map(condition);
return(BlobStorageUtil.Write(mapped, _blob, writer, writeOptions));
}
catch (StorageServerException ex)
{
switch (ex.ErrorCode)
{
case StorageErrorCode.ServiceIntegrityCheckFailed:
throw StreamingErrors.IntegrityFailure(this, ex);
default:
throw;
}
}
catch (StorageClientException ex)
{
switch (ex.ErrorCode)
{
case StorageErrorCode.ConditionFailed:
throw StreamingErrors.ConditionFailed(this, condition, ex);
case StorageErrorCode.ContainerNotFound:
throw StreamingErrors.ContainerNotFound(this, ex);
default:
throw;
}
}
}
public Optional <StreamingItemInfo> GetInfo(StreamingCondition condition)
{
try
{
_blob.FetchAttributes(Map(condition));
return(BlobStorageUtil.MapFetchedAttrbitues(_blob));
}
catch (StorageClientException e)
{
switch (e.ErrorCode)
{
case StorageErrorCode.ContainerNotFound:
case StorageErrorCode.ResourceNotFound:
case StorageErrorCode.BlobNotFound:
case StorageErrorCode.ConditionFailed:
return(Optional <StreamingItemInfo> .Empty);
case StorageErrorCode.BadRequest:
switch (e.StatusCode)
{
case HttpStatusCode.PreconditionFailed:
return(Optional <StreamingItemInfo> .Empty);
default:
throw;
}
}
throw;
}
}
/// <summary>
/// Creates this storage item from another.
/// </summary>
/// <param name="sourceItem">The target.</param>
/// <param name="condition">The condition.</param>
/// <param name="copySourceCondition">The copy source condition.</param>
/// <param name="options">The options.</param>
/// <exception cref="StreamingItemNotFoundException">when source storage is not found</exception>
/// <exception cref="StreamingItemIntegrityException">when integrity check fails</exception>
public void CopyFrom(IStreamingItem sourceItem, StreamingCondition condition, StreamingCondition copySourceCondition,
StreamingWriteOptions options)
{
var item = sourceItem as FileStreamingItem;
if (item != null)
{
Refresh();
ThrowIfContainerNotFound();
ThrowIfConditionFailed(condition);
item.Refresh();
item.ThrowIfContainerNotFound();
item.ThrowIfItemNotFound();
item.ThrowIfConditionFailed(copySourceCondition);
item._file.CopyTo(_file.FullName, true);
}
else
{
const int bufferSize = 64 * 1024;
Write(
targetStream =>
sourceItem.ReadInto((props, stream) => stream.CopyTo(targetStream, bufferSize),
copySourceCondition), condition, options);
}
}
void ThrowIfConditionFailed(StreamingCondition condition)
{
if (!Satisfy(condition))
{
throw StreamingErrors.ConditionFailed(this, condition);
}
}
public static Exception ConditionFailed(IStreamingItem item, StreamingCondition condition, Exception inner = null)
{
var message = string.Format(CultureInfo.InvariantCulture, "Storage condition '{0}' failed for '{1}'",
condition,
item.FullPath);
return(new StreamingConditionFailedException(message, inner));
}
bool Satisfy(StreamingCondition condition)
{
var info = GetUnconditionalInfo();
return(info
.Convert(s => new LocalStreamingInfo(s.ETag))
.Convert(s => condition.Satisfy(s), () => condition.Satisfy()));
}
/// <summary>
/// Gets the info about this item. It returns empty result if the item does not exist or does not match the condition
/// </summary>
/// <param name="condition">The condition.</param>
/// <returns></returns>
public Optional <StreamingItemInfo> GetInfo(StreamingCondition condition)
{
Refresh();
//ThrowIfContainerNotFound();
if (_file.Exists && Satisfy(condition))
{
return(GetUnconditionalInfo());
}
return(Optional <StreamingItemInfo> .Empty);
}
/// <summary>
/// Removes the item, ensuring that the specified condition is met.
/// </summary>
/// <param name="condition">The condition.</param>
public void Delete(StreamingCondition condition)
{
Refresh();
ThrowIfContainerNotFound();
if (_file.Exists && Satisfy(condition))
{
_file.Delete();
}
}
static BlobRequestOptions Map(StreamingCondition condition,
StreamingCondition copySourceAccessCondition = default(StreamingCondition))
{
if ((condition.Type == StreamingConditionType.None) &&
(copySourceAccessCondition.Type == StreamingConditionType.None))
{
return(null);
}
return(new BlobRequestOptions
{
AccessCondition = MapCondition(condition),
CopySourceAccessCondition = MapCondition(copySourceAccessCondition)
});
}
/// <summary>
/// Attempts to read the storage item.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="condition">The condition.</param>
/// <exception cref="StreamingItemNotFoundException">if the item does not exist.</exception>
/// <exception cref="StreamingContainerNotFoundException">if the container for the item does not exist</exception>
/// <exception cref="StreamingItemIntegrityException">when integrity check fails</exception>
public void ReadInto(ReaderDelegate reader, StreamingCondition condition)
{
Refresh();
ThrowIfContainerNotFound();
ThrowIfItemNotFound();
ThrowIfConditionFailed(condition);
var props = GetUnconditionalInfo().Value;
using (var read = _file.OpenRead())
{
reader(props, read);
}
}
/// <summary>
/// Performs the write operation, ensuring that the condition is met.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="condition">The condition.</param>
/// <param name="options">The options.</param>
/// <returns>number of bytes written</returns>
/// <exception cref="StreamingItemIntegrityException">when integrity check fails during the upload</exception>
public long Write(Action <Stream> writer, StreamingCondition condition, StreamingWriteOptions options)
{
Refresh();
ThrowIfContainerNotFound();
ThrowIfConditionFailed(condition);
using (var file = _file.OpenWrite())
{
writer(file);
// stream will probably be closed here.
}
Refresh();
return(_file.Length);
}
/// <summary>
/// Attempts to read the storage item.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="condition">The condition.</param>
/// <exception cref="StreamingItemNotFoundException">if the item does not exist.</exception>
/// <exception cref="StreamingContainerNotFoundException">if the container for the item does not exist</exception>
/// <exception cref="StreamingItemIntegrityException">when integrity check fails</exception>
public void ReadInto(ReaderDelegate reader, StreamingCondition condition)
{
try
{
var mapped = Map(condition);
BlobStorageUtil.Read(mapped, _blob, reader);
}
catch (StreamingItemIntegrityException e)
{
throw StreamingErrors.IntegrityFailure(this, e);
}
catch (StorageClientException e)
{
switch (e.ErrorCode)
{
case StorageErrorCode.ContainerNotFound:
throw StreamingErrors.ContainerNotFound(this, e);
case StorageErrorCode.ResourceNotFound:
case StorageErrorCode.BlobNotFound:
throw StreamingErrors.ItemNotFound(this, e);
case StorageErrorCode.ConditionFailed:
throw StreamingErrors.ConditionFailed(this, condition, e);
case StorageErrorCode.ServiceIntegrityCheckFailed:
throw StreamingErrors.IntegrityFailure(this, e);
case StorageErrorCode.BadRequest:
switch (e.StatusCode)
{
// for some reason Azure Storage happens to get here as well
case HttpStatusCode.PreconditionFailed:
case HttpStatusCode.NotModified:
throw StreamingErrors.ConditionFailed(this, condition, e);
default:
throw;
}
default:
throw;
}
}
}
static AccessCondition MapCondition(StreamingCondition condition)
{
switch (condition.Type)
{
case StreamingConditionType.None:
return(AccessCondition.None);
case StreamingConditionType.IfMatch:
var x = ExposeException(condition.ETag, "'ETag' should be present");
return(AccessCondition.IfMatch(x));
case StreamingConditionType.IfNoneMatch:
var etag = ExposeException(condition.ETag, "'ETag' should be present");
return(AccessCondition.IfNoneMatch(etag));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Removes the item, ensuring that the specified condition is met.
/// </summary>
/// <param name="condition">The condition.</param>
public void Delete(StreamingCondition condition)
{
try
{
var options = Map(condition);
_blob.Delete(options);
}
catch (StorageClientException ex)
{
switch (ex.ErrorCode)
{
case StorageErrorCode.ContainerNotFound:
throw StreamingErrors.ContainerNotFound(this, ex);
case StorageErrorCode.BlobNotFound:
case StorageErrorCode.ConditionFailed:
return;
default:
throw;
}
}
}
public void CopyFrom(IStreamingItem sourceItem,
StreamingCondition condition,
StreamingCondition copySourceCondition,
StreamingWriteOptions writeOptions)
{
var item = sourceItem as BlobStreamingItem;
if (item != null)
{
try
{
_blob.CopyFromBlob(item._blob, Map(condition, copySourceCondition));
}
catch (StorageClientException e)
{
switch (e.ErrorCode)
{
case StorageErrorCode.BlobNotFound:
throw StreamingErrors.ItemNotFound(this, e);
default:
throw;
}
}
}
else
{
// based on the default write block size of BLOB
const int bufferSize = 0x400000;
Write(
targetStream =>
sourceItem.ReadInto(
(props, stream) => stream.CopyTo(targetStream, bufferSize),
copySourceCondition), condition,
writeOptions);
}
}
