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);
 }
示例#2
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);
            }
        }
 public static Exception IntegrityFailure(IStreamingItem item, Exception inner = null)
 {
     var message = string.Format(CultureInfo.InvariantCulture,
         "Local hash differs from metadata. Item was probably corrupted in trasfer, please retry: '{0}'.",
         item.FullPath);
     return new StreamingItemIntegrityException(message, inner);
 }
        public static Exception ContainerNotFound(IStreamingItem item, Exception inner = null)
        {
            var message = string.Format(CultureInfo.InvariantCulture, "Storage container was not found for: '{0}'.",
                                        item.FullPath);

            return(new StreamingContainerNotFoundException(message, inner));
        }
        /// <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);
            }
        }
        public static Exception IntegrityFailure(IStreamingItem item, Exception inner = null)
        {
            var message = string.Format(CultureInfo.InvariantCulture,
                                        "Local hash differs from metadata. Item was probably corrupted in trasfer, please retry: '{0}'.",
                                        item.FullPath);

            return(new StreamingItemIntegrityException(message, inner));
        }
        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));
        }
示例#8
0
 public static void WriteText(this IStreamingItem item, string text, Encoding encoding)
 {
     item.Write(s =>
     {
         using (var writer = new StreamWriter(s, encoding))
         {
             writer.Write(text);
         }
     });
 }
示例#9
0
        public static string ReadText(this IStreamingItem item)
        {
            string result = null;

            item.ReadInto((props, stream) =>
            {
                using (var reader = new StreamReader(stream))
                {
                    result = reader.ReadToEnd();
                }
            });

            return(result);
        }
        /// <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);
        }
示例#11
0
        protected void ShouldHaveBytes(IStreamingItem streamingItem, byte[] bytes,
                                       StreamingCondition condition = default(StreamingCondition))
        {
            StreamingItemInfo streamingItemInfo = null;

            byte[] actualBytes = null;

            using (var ms = new MemoryStream())
            {
                streamingItem.ReadInto((properties, stream) =>
                {
                    stream.CopyTo(ms);
                    actualBytes       = ms.ToArray();
                    streamingItemInfo = properties;
                }, condition);
            }
            Assert.AreEqual(bytes, actualBytes);
            Assert.That(streamingItemInfo.ETag, Is.Not.Empty);
        }
示例#12
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);
            }
        }
示例#13
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);
            }
        }
示例#14
0
        protected void ShouldHaveGuid(IStreamingItem streamingItem, Guid g,
                                      StreamingCondition condition = default(StreamingCondition))
        {
            var  set    = false;
            Guid actual = Guid.Empty;
            StreamingItemInfo streamingItemInfo = null;

            streamingItem.ReadInto((properties, stream) =>
            {
                var b = new byte[16];
                stream.Read(b, 0, 16);
                actual            = new Guid(b);
                set               = true;
                streamingItemInfo = properties;
            }, condition);

            Assert.AreEqual(g, actual);

            Assert.That(streamingItemInfo.ETag, Is.Not.Empty);

            set = true;

            Assert.IsTrue(set);
        }
 internal bool Contains(IStreamingItem item)
 {
     return(GetRealContainer()._items.ContainsKey(item.FullPath));
 }
示例#16
0
 protected void Write(IStreamingItem streamingItem, byte[] bytes, StreamingCondition condition = default(StreamingCondition))
 {
     streamingItem.Write(stream => stream.Write(bytes, 0, bytes.Length), condition, WriteOptions);
 }
示例#17
0
 protected void TryToRead(IStreamingItem item, StreamingCondition condition = default(StreamingCondition))
 {
     item.ReadInto((props, stream) => stream.Read(new byte[1], 0, 1), condition);
 }
 public static Exception ItemNotFound(IStreamingItem item, Exception inner = null)
 {
     var message = string.Format(CultureInfo.InvariantCulture, "Storage item was not found: '{0}'.",
         item.FullPath);
     return new StreamingItemNotFoundException(message, inner);
 }
 internal bool Contains(IStreamingItem item)
 {
     return GetRealContainer()._items.ContainsKey(item.FullPath);
 }
示例#20
0
 protected void Write(IStreamingItem streamingItem, Guid g, StreamingCondition condition = default(StreamingCondition))
 {
     streamingItem.Write(stream => stream.Write(g.ToByteArray(), 0, 16), condition, WriteOptions);
 }