/// <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); } }
//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; } } }
/// <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); } }
/// <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 = OpenForWrite()) { writer(file); // stream will probably be closed here. } Refresh(); return(_file.Length); }
public static long Write(BlobRequestOptions mapped, CloudBlob blob, Action <Stream> writer, StreamingWriteOptions writeOptions) { var compressIfPossible = (writeOptions & StreamingWriteOptions.CompressIfPossible) == StreamingWriteOptions.CompressIfPossible; // we are adding our own hashing on top, to ensure // consistent behavior between Azure StorageClient versions if (compressIfPossible) { return(WriteWithCompression(blob, mapped, writer)); } { return(WriteWithoutCompression(blob, mapped, writer)); } }
/// <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 = new StreamingCondition(), StreamingCondition copySourceCondition = new StreamingCondition(), StreamingWriteOptions options = StreamingWriteOptions.None) { var source = sourceItem as MemoryStreamingItem; if (source != null) { ThrowIfContainerNotFound(); ThrowIfConditionFailed(condition); source.ThrowIfContainerNotFound(); source.ThrowIfItemNotFound(); source.ThrowIfConditionFailed(copySourceCondition); _content = source._content; _parent.Add(this); } else Write(targetStream => sourceItem.ReadInto((props, stream) => stream.CopyTo(targetStream, 65536), copySourceCondition), condition, options); }
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); } }
/// <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 = OpenForWrite()) { writer(file); // stream will probably be closed here. } Refresh(); return _file.Length; }
/// <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 = new StreamingCondition(), StreamingWriteOptions options = StreamingWriteOptions.None) { ThrowIfContainerNotFound(); ThrowIfConditionFailed(condition); _parent.Add(this); using (var stream = new MemoryStream()) { writer(stream); _content = stream.ToArray(); } return(_content.Length); }
/// <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 = new StreamingCondition(), StreamingCondition copySourceCondition = new StreamingCondition(), StreamingWriteOptions options = StreamingWriteOptions.None) { var source = sourceItem as MemoryStreamingItem; if (source != null) { ThrowIfContainerNotFound(); ThrowIfConditionFailed(condition); source.ThrowIfContainerNotFound(); source.ThrowIfItemNotFound(); source.ThrowIfConditionFailed(copySourceCondition); _content = source._content; _parent.Add(this); } else { Write(targetStream => sourceItem.ReadInto((props, stream) => stream.CopyTo(targetStream, 65536), copySourceCondition), condition, options); } }
public static long Write(BlobRequestOptions mapped, CloudBlob blob, Action<Stream> writer, StreamingWriteOptions writeOptions) { var compressIfPossible = (writeOptions & StreamingWriteOptions.CompressIfPossible) == StreamingWriteOptions.CompressIfPossible; // we are adding our own hashing on top, to ensure // consistent behavior between Azure StorageClient versions if (compressIfPossible) { return WriteWithCompression(blob, mapped, writer); } { return WriteWithoutCompression(blob, mapped, writer); } }
/// <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 = new StreamingCondition(), StreamingWriteOptions options = StreamingWriteOptions.None) { ThrowIfContainerNotFound(); ThrowIfConditionFailed(condition); _parent.Add(this); using (var stream = new MemoryStream()) { writer(stream); _content = stream.ToArray(); } return _content.Length; }