Example #1
0
 public void Update(BinaryStorageClass details)
 {
     lock (_lock)
     {
         _file.Write(details);
         _file.Commit();
     }
 }
Example #2
0
        /// <summary>
        /// Add a binary to the file and store the data in the data cache.
        ///
        /// It should be noted that there is a failure mode in which the commit of the binary details file could work, but the commit
        /// of the data could fail. This would result in the record of the binary being stored, but no actual data would be present
        /// in the files. This would manifest itself as an exception, which is caught here, and an attempt to remove the binary details
        /// is made. In the event that the data commit fails because of catastrophic failure or power loss, the recovery attempt may not
        /// take place or may itself fail. This would leave the data in an inconsistent state, but only for the most recently saved binary.
        ///
        /// On open, the most recently saved binary is checked, to see if the data is present. If it is not, it is removed at that stage.
        /// On the assumption that the failure to
        /// </summary>
        /// <param name="details"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public Guid Add(BinaryStorageClass details, byte[] data)
        {
            lock (_lock)
            {
                try
                {
                    if (details.Id == Guid.Empty)
                    {
                        details.Id = Guid.NewGuid();
                    }
                    details.FileIndex        = _nextIndex++;
                    details.FirstDataBlockId = _data.Write(data);
                    _file.Write(details);
                    _file.Commit();

                    _binaries.Add(details.Id, details);

                    //Make sure that the file is removed if commit fails.
                    Action reverseOutFile = () =>
                    {
                        // ReSharper disable AccessToDisposedClosure
                        //Note: Resharper cannot determine whether the lambda will outlive the try/catch block. It can't so we can ignore the warning.
                        _file.Delete(details);
                        _file.Commit();
                        // ReSharper restore AccessToDisposedClosure
                    };

                    using (var reverse = new OnError(reverseOutFile))
                    {
                        _data.Commit();
                        reverse.Commit(); //if we reach here, the commit worked and we don't need to reverse out the file.
                    }

                    return(details.Id);
                }
                catch
                {
                    _file.Dispose();
                    _file = null;
                    Open(_path);
                    _data.ReOpen();
                    throw;
                }
            }
        }
Example #3
0
            public BinaryStorageClass AddFile(byte[] data, string name, string[] path, DateTime fileDateUtc, string fileContainerPath)
            {
                var nameTag         = _tagCache.AddOrGet(name);
                var originalPathTag = _tagCache.AddOrGet(fileContainerPath);
                var pathId          = _pathsCache.AddOrGet(path);

                var binary = new BinaryStorageClass
                {
                    Id                  = Guid.NewGuid(),
                    DateAdded           = DateTime.Now.ToUniversalTime(),
                    OriginalBinaryDate  = fileDateUtc,
                    OriginalFileNameTag = nameTag,
                    OriginalPathTag     = originalPathTag,
                    NameTag             = nameTag,
                    PathId              = pathId,
                };

                _binariesCache.Add(binary, data);

                return(binary);
            }