Ejemplo n.º 1
0
        /// <summary>
        ///     Replaces a chunk with another one
        /// </summary>
        /// <param name="id">Chunk id to replace</param>
        /// <param name="chunk">Replacement chunk</param>
        internal void ReplaceChunk(uint id, StorageChunk chunk)
        {
            Cache = null;
            var index = ChunkDictionary[id];

            FailIndex(index);
            ChunkList[index] = chunk;
            ChunkDictionary.Remove(id);
            ChunkDictionary[chunk.Id] = index;
        }
Ejemplo n.º 2
0
        /// <summary>
        ///     REmoves a chunk from the chunk list
        /// </summary>
        /// <param name="chunk">Chunk to remove</param>
        internal void RemoveChunk(StorageChunk chunk)
        {
            Cache = null;
            var index = ChunkDictionary[chunk.Id];

            ChunkList.RemoveAt(index);

            // Force recreation of ChunkDictionary
            ChunkList = ChunkList;
            //ChunkDictionary.Remove(chunk.Id);
        }
Ejemplo n.º 3
0
        /// <summary>
        ///     Reads the info from a stream
        /// </summary>
        /// <param name="stream">Stream to read from</param>
        /// <param name="cached">Cached storage info, if added and removed version values are the same returns it instead of reading from the stream again</param>
        /// <returns>Storage info in the stream</returns>
        internal static StorageInfo ReadFromStream(Stream stream, StorageInfo cached)
        {
            using (var r = new BinaryReader(stream, Encoding.UTF8))
            {
                var i  = r.ReadBoolean();
                var mv = r.ReadUInt64();

                if (cached != null && cached.Initialized == i && cached.ModifiedVersion == mv)
                {
                    return new StorageInfo {
                               Initialized = cached.Initialized, AddedVersion = cached.AddedVersion, RemovedVersion = cached.RemovedVersion, ModifiedVersion = cached.ModifiedVersion, _chunkList = cached._chunkList?.ToList(), ChunkDictionary = cached.ChunkDictionary?.ToDictionary(kv => kv.Key, kv => kv.Value), _stableChunkList = cached._stableChunkList?.ToList(), Cache = cached
                    }
                }
                ;

                var av = r.ReadUInt64();
                var rv = r.ReadUInt64();

                var count = r.ReadInt32();

                var si = new StorageInfo
                {
                    Initialized     = i,
                    ModifiedVersion = mv,
                    AddedVersion    = av,
                    RemovedVersion  = rv
                };

                for (var c = 0; c < count; c++)
                {
                    si.AddChunk(StorageChunk.FromStream(r));
                }

                return(si);
            }
        }
Ejemplo n.º 4
0
 /// <summary>
 ///     Adds a new chunk to the chunk list
 /// </summary>
 /// <param name="chunk">Chunk to add</param>
 internal void AddChunk(StorageChunk chunk)
 {
     Cache = null;
     ChunkList.Add(chunk);
     ChunkDictionary[chunk.Id] = ChunkList.Count - 1;
 }
Ejemplo n.º 5
0
 /// <summary>
 ///     Updates an existing chunk
 /// </summary>
 /// <param name="chunk">Chunk to update</param>
 internal void UpdateChunk(StorageChunk chunk)
 {
     ReplaceChunk(chunk.Id, chunk);
 }
Ejemplo n.º 6
0
        /// <summary>
        ///     Adds a chunk to the blob
        /// </summary>
        /// <param name="chunkType">Chunk type</param>
        /// <param name="userData">Chunk user data</param>
        /// <param name="data">Stream to add</param>
        /// <param name="token">Cancellation token</param>
        /// <returns>StorageChunk of the added chunk</returns>
        public Task <StorageChunk> AddChunk(int chunkType, uint userData, Stream data, CancellationToken token)
        {
            return(Task.Factory.StartNew(async() =>
            {
                var l = data.Length - data.Position;

                if (l > uint.MaxValue)
                {
                    throw new InvalidDataException("Chunk length greater than uint.MaxValue");
                }

                var size = (uint)l;

                var chunk = default(StorageChunk);

                using (var f = await Open(token))
                {
                    long lockSize = 0;
                    var ff = f;

                    await Lock(ConcurrencyHandler.Timeout, token, false, () =>
                    {
                        var info = ReadInfo();

                        CheckInitialized(info);

                        // Check for exact size free chunk
                        var free = info.Chunks.FirstOrDefault(fc => !fc.Changing && fc.Size == size && fc.Type == ChunkTypes.Free);
                        if (free.Type != ChunkTypes.Free)
                        {
                            // Check for free chunk bigger than required
                            free = info.Chunks.FirstOrDefault(fc => !fc.Changing && fc.Size > size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize && fc.Type == ChunkTypes.Free);
                        }
                        StorageChunk?newFree = null;

                        if (free.Type == ChunkTypes.Free)
                        {
                            // if free space found in blob
                            if (free.Size == size)
                            {
                                // if chunk size equals with the free space size, replace free space with chunk
                                chunk = new StorageChunk(free.Id, userData, chunkType, free.Position, size, DateTime.UtcNow)
                                {
                                    Changing = true
                                };
                                info.ReplaceChunk(free.Id, chunk);
                                lockSize = size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize;
                                Log($"Replacing free chunk {free} with chunk {chunk}");
                            }
                            else
                            {
                                // chunk size < free space size, remove chunk sized portion of the free space
                                newFree = new StorageChunk(free.Id, 0, ChunkTypes.Free, free.Position + size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize, free.Size - size - StorageChunk.ChunkHeaderSize - StorageChunk.ChunkFooterSize, DateTime.UtcNow);
                                info.UpdateChunk(newFree.Value);
                                chunk = new StorageChunk(GetId(info.Chunks), userData, chunkType, free.Position, size, DateTime.UtcNow)
                                {
                                    Changing = true
                                };
                                info.AddChunk(chunk);
                                lockSize = free.Size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize;
                                Log($"Split free chunk {free} to chunk {chunk} and free {newFree}");
                            }
                        }
                        else
                        {
                            // no space found, add chunk at the end of the file
                            var last = info.Chunks.OrderByDescending(ch => ch.Position).FirstOrDefault();
                            var position = last.Position == 0 ? HeaderSize : last.Position + last.Size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize;
                            chunk = new StorageChunk(GetId(info.Chunks), userData, chunkType, position, size, DateTime.UtcNow)
                            {
                                Changing = true
                            };
                            info.AddChunk(chunk);
                            lockSize = chunk.Size + StorageChunk.ChunkHeaderSize + StorageChunk.ChunkFooterSize;
                            Log($"Add chunk {chunk}");
                        }

                        using (var fr = ff.Range(chunk.Position, lockSize, LockMode.Exclusive))
                            using (var w = new BinaryWriter(fr, Encoding.UTF8))
                            {
                                if (fr.Stream.Length < chunk.Position + lockSize)
                                {
                                    fr.Stream.SetLength(chunk.Position + lockSize);
                                }

                                if (newFree.HasValue)
                                {
                                    // write out new free chunk header
                                    fr.Position = newFree.Value.Position - chunk.Position;
                                    newFree.Value.ToStorage(w);
                                    fr.Flush();
                                }

                                // write chunk data to blob with FREE chunk type
                                fr.Position = 0;
                                chunk.ToStorage(w, true);
                                fr.Flush();
                            }

                        WriteInfo(info, true);
                    });

                    var ok = false;

                    try
                    {
                        using (var fr = f.Range(chunk.Position, lockSize, LockMode.Exclusive))
                            using (var w = new BinaryWriter(fr, Encoding.UTF8))
                            {
                                fr.Position = StorageChunk.ChunkHeaderSize;

                                // write chunk data to stream
                                var buffer = new byte[81920];
                                long remaining = size;
                                ushort crc = 0;
                                while (remaining > 0)
                                {
                                    var bytesRead = await data.ReadAsync(buffer, 0, (int)Math.Min(remaining, buffer.Length), token).ConfigureAwait(false);
                                    crc = Crc16.ComputeChecksum(buffer, 0, bytesRead, crc);
                                    if (bytesRead != 0)
                                    {
                                        await fr.WriteAsync(buffer, 0, bytesRead, token).ConfigureAwait(false);
                                    }
                                    else
                                    {
                                        break;
                                    }
                                    remaining -= bytesRead;
                                }
                                w.Write(crc);
                                fr.Flush();

                                // write correct chunk type
                                fr.Position = 0;
                                chunk.ToStorage(w);
                                fr.Flush();

                                ok = true;
                            }
                    }
                    finally
                    {
                        await Lock(ConcurrencyHandler.Timeout * 4, CancellationToken.None, true, () =>
                        {
                            var info = ReadInfo();

                            CheckInitialized(info);

                            // Exception occured, chunk should stay free
                            if (!ok)
                            {
                                chunk = info.GetChunkById(chunk.Id);
                            }

                            chunk.Changing = false;
                            info.UpdateChunk(chunk);

                            info.AddedVersion++;
                            WriteInfo(info, true);
                        });
                    }
                }
                return chunk;
            }, token, TaskCreationOptions.DenyChildAttach, Scheduler).Unwrap());
        }