/// <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);
            }
        }
Example #2
0
        //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;
                }
            }
        }
Example #3
0
        /// <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);
            }
        }
Example #4
0
        /// <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);
        }
Example #5
0
        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);
        }
Example #7
0
        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;
        }
Example #9
0
        /// <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);
        }
Example #10
0
        /// <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;
        }