示例#1
0
        public static bool CheckIfValid(string fileName)
        {
            IFileHeader rawHeader = null;

            // try to open the raw file header
            try
            {
                rawHeader = FileHeaderReaderFactory.ReadFile(fileName);
            }
            catch (Exception)
            {
                Log.Information("{File} is not a valid raw file", fileName);
                Console.WriteLine("{0} is not a valid raw file.", fileName);
                return(false);
            }

            // is it a real raw file?
            if (rawHeader.FileType == FileType.RawFile)
            {
                Log.Information("{File} is a valid raw file", fileName);
                Log.Information("Creation date: {Date}", rawHeader.CreationDate);
                Log.Information("File description: {Description}", rawHeader.FileDescription);
                return(true);
            }
            else
            {
                Log.Information("{File} is not a valid raw file", fileName);
                Console.WriteLine("{0} is not a valid raw file, continuing to next file.", fileName);
                return(false);
            }
        }
示例#2
0
        private static GlobalCache CreateCache(IFileHeader oldHeader, RegulatoryElement[] regulatoryElements)
        {
            var header = new FileHeader(CacheConstants.Identifier, CacheConstants.SchemaVersion,
                                        CacheConstants.DataVersion, oldHeader.TranscriptSource, DateTime.Now.Ticks, oldHeader.GenomeAssembly,
                                        oldHeader.Custom);

            return(new GlobalCache(header, null, regulatoryElements, null, null, null, null));
        }
        private void EnsureMetadata(IBlobMetadata blobMetadata, IFileHeader fileHeader, long fileAbsoluteStartPosition, long fileAbsoluteEndPosition)
        {
            if (blobMetadata == null)
            {
                throw new ArgumentNullException("blobMetadata");
            }

            if (fileHeader == null)
            {
                throw new ArgumentNullException("fileHeader");
            }

            if (fileAbsoluteStartPosition < 0)
            {
                throw new ArgumentNullException("fileAbsolutePosition");
            }

            if (fileAbsoluteEndPosition < 0)
            {
                throw new ArgumentNullException("fileAbsoluteEndPosition");
            }

            if (fileAbsoluteStartPosition >= fileAbsoluteEndPosition)
            {
                throw new Exception("fileAbsoluteStartPosition не может быть больше fileAbsoluteEndPosition");
            }

            IFolderMetadata   folderMetadata   = this.DataAdapter.MetadataAdapter.EnsureFolder(fileHeader.FolderUrl);
            IBlobFileMetadata blobFileMetadata = this.DataAdapter.BlobMetadataAdapter.GetFile(folderMetadata, fileHeader.UniqueID);

            if (blobFileMetadata != null)
            {
                //файл есть, проверяем текущую версию, есть ли она
                ICollection <IBlobFileVersionMetadata> versions = this.DataAdapter.BlobMetadataAdapter.GetVersions(blobFileMetadata);
                bool versionExists = false;
                if (versions != null)
                {
                    foreach (IBlobFileVersionMetadata version in versions)
                    {
                        if (version.UniqueID == fileHeader.VersionUniqueID)
                        {
                            versionExists = true;
                            break;
                        }
                    }
                }

                if (!versionExists)
                {
                    this.DataAdapter.BlobMetadataAdapter.AddExistsFileVersion(this.DataAdapter.MetadataAdapter.CurrentStorage, blobMetadata, folderMetadata, fileHeader, fileAbsoluteStartPosition, fileAbsoluteEndPosition);
                }
            }
            else
            {
                //файла нет, создаем метаданные файла
                this.DataAdapter.BlobMetadataAdapter.AddExistsFileVersion(this.DataAdapter.MetadataAdapter.CurrentStorage, blobMetadata, folderMetadata, fileHeader, fileAbsoluteStartPosition, fileAbsoluteEndPosition);
            }
        }
示例#4
0
        public static GlobalCustomHeader GetCustomHeader(IFileHeader header)
        {
            var customHeader = header.Custom as GlobalCustomHeader;

            if (customHeader == null)
            {
                throw new InvalidCastException("Could not case header.Custom to GlobalCustomHeader");
            }
            return(customHeader);
        }
示例#5
0
 /// <summary>
 /// constructor
 /// </summary>
 public GlobalCache(IFileHeader header, Transcript[] transcripts, RegulatoryElement[] regulatoryElements,
                    Gene[] genes, SimpleInterval[] introns, SimpleInterval[] microRnas, string[] peptideSeqs)
 {
     Header             = header;
     Transcripts        = transcripts;
     RegulatoryElements = regulatoryElements;
     Genes       = genes;
     Introns     = introns;
     MicroRnas   = microRnas;
     PeptideSeqs = peptideSeqs;
 }
示例#6
0
        public IFileHeader ReadHeader(IFileHeader tempHeader)
        {
            IFileHeader header;

            using (var reader = new BinaryReader(_stream, Encoding.UTF8, true))
            {
                header = tempHeader.Read(reader);
            }

            return(header);
        }
示例#7
0
        /// <summary>
        /// deserializes the prediction cache associated with a particular index entry (reference seq)
        /// </summary>
        public static PredictionCache Read(BinaryReader reader, Prediction.Entry[] lookupTable, IndexEntry indexEntry,
                                           IFileHeader header)
        {
            var predictions = new Prediction[indexEntry.Count];

            for (int i = 0; i < indexEntry.Count; i++)
            {
                predictions[i] = Prediction.Read(reader, lookupTable);
            }

            return(new PredictionCache(header, lookupTable, predictions));
        }
示例#8
0
        public static bool CheckIfFilePresentInQcCollection(string fileName, QcDataCollection qcDataCollection)
        {
            IFileHeader rawHeader = FileHeaderReaderFactory.ReadFile(fileName);

            if (qcDataCollection.QcData.Keys.Contains(rawHeader.CreationDate))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#9
0
        public void ShouldReadSampleFormatFromByte25()
        {
            // Arrange
            var  expected       = FormatCode.IeeeFloatingPoint4;
            bool isLittleEndian = false;

            // Act
            IFileHeader result = Set16BitValueInBinaryStreamAndRead((sr, br) => sr.ReadBinaryHeader(br), 25, (Int16)expected, isLittleEndian);

            // Assert
            Assert.AreEqual(expected, result.SampleFormat);
            Assert.AreEqual(isLittleEndian, result.IsLittleEndian);
        }
示例#10
0
        public void ShouldDetectLittleEndiannessFromSampleFormat()
        {
            // Arrange
            var  expected       = FormatCode.TwosComplementInteger1;
            bool isLittleEndian = true;

            // Act
            IFileHeader result = Set16BitValueInBinaryStreamAndRead((sr, br) => sr.ReadBinaryHeader(br), 25, (Int16)expected, isLittleEndian);

            // Assert
            Assert.AreEqual(expected, result.SampleFormat);
            Assert.AreEqual(isLittleEndian, result.IsLittleEndian);
        }
示例#11
0
        public void ShouldReadTextAndBinaryHeaderGivenBinaryReader()
        {
            // Arrange
            using (var stream = File.OpenRead(_example))
                using (var reader = new BinaryReader(stream))
                {
                    // Act
                    IFileHeader fileHeader = Subject.ReadFileHeader(reader);

                    // Assert
                    Assert.AreEqual(Subject.ReadTextHeader(_example), fileHeader.Text);
                    Assert.AreEqual(FormatCode.IbmFloatingPoint4, fileHeader.SampleFormat);
                }
        }
示例#12
0
        private PhotonFile ReadFile(byte[] file, Action <string> reportProgress)
        {
            reportProgress?.Invoke("Reading Photon file header information...");
            var photonFileHeader = new PhotonFileHeader(file);

            iFileHeader = photonFileHeader;

            reportProgress?.Invoke("Reading photon large preview image information...");
            previewOne = new PhotonFilePreview(photonFileHeader.GetPreviewOneOffsetAddress(), file);
            reportProgress?.Invoke("Reading photon small preview image information...");
            previewTwo = new PhotonFilePreview(photonFileHeader.GetPreviewTwoOffsetAddress(), file);
            if (photonFileHeader.GetVersion() > 1)
            {
                reportProgress?.Invoke("Reading Print parameters information...");
                photonFileHeader.ReadParameters(file);
            }
            reportProgress?.Invoke("Reading photon layers information...");
            layers = PhotonFileLayer.ReadLayers(photonFileHeader, file, margin, reportProgress);
            ResetMarginAndIslandInfo();

            return(this);
        }
示例#13
0
 public void UnLink()
 {
     while (layers.Count > 0)
     {
         PhotonFileLayer layer = layers[0];
         layers.RemoveAt(0);
         layer.UnLink();
     }
     if (islandLayers != null)
     {
         islandLayers.Clear();
     }
     if (marginLayers != null)
     {
         marginLayers.Clear();
     }
     iFileHeader.UnLink();
     iFileHeader = null;
     previewOne.UnLink();
     previewOne = null;
     previewTwo.UnLink();
     previewTwo = null;
 }
示例#14
0
 /// <summary>
 /// constructor
 /// </summary>
 private PredictionCache(IFileHeader header, Prediction.Entry[] lookupTable, Prediction[] predictions)
 {
     Header      = header;
     LookupTable = lookupTable;
     Predictions = predictions;
 }
示例#15
0
 /// <summary>
 /// constructor
 /// </summary>
 public TranscriptCacheBuilder(IFileHeader header, List <TranscriptPacket> packets)
 {
     _originalHeader = header;
     _packets        = packets;
 }
示例#16
0
        /// <summary>
        /// Создает метаданные существующего файла.
        /// </summary>
        /// <param name="storageMetadata">Метаданные хранилища.</param>
        /// <param name="blobMetadata">Метаданные блоба.</param>
        /// <param name="folderMetadata">Метаданные папки.</param>
        /// <param name="fileHeader">Заголовок файла.</param>
        /// <param name="blobStartPosition">Начальная позиция файла в блобе.</param>
        /// <param name="blobEndPosition">Конечная позиция файла в блобе.</param>
        /// <returns></returns>
        public IBlobFileMetadata AddExistsFileVersion(IStorageMetadata storageMetadata, IBlobMetadata blobMetadata, IFolderMetadata folderMetadata, IFileHeader fileHeader, long blobStartPosition, long blobEndPosition)
        {
            if (storageMetadata == null)
            {
                throw new ArgumentNullException("storageMetadata");
            }

            if (blobMetadata == null)
            {
                throw new ArgumentNullException("blobMetadata");
            }

            if (folderMetadata == null)
            {
                throw new ArgumentNullException("folderMetadata");
            }

            if (fileHeader == null)
            {
                throw new ArgumentNullException("fileHeader");
            }

            if (blobStartPosition < 0)
            {
                throw new ArgumentNullException("blobStartPosition");
            }

            IBlobFileHeader blobHeader  = (IBlobFileHeader)((object)fileHeader);
            FileMetadata    file        = this.FileAdapter.GetFile(fileHeader.UniqueID, folderMetadata);
            bool            justCreated = false;

            if (file == null)
            {
                justCreated          = true;
                file                 = new FileMetadata(this.FileAdapter);
                file.UniqueID        = fileHeader.UniqueID;
                file.VersionUniqueID = fileHeader.VersionUniqueID;
                file.FolderID        = folderMetadata.ID;
                file.FolderMetadata  = folderMetadata;
                file.Name            = fileHeader.FileName;

                file.BlobID            = blobMetadata.ID;
                file.BlobStartPosition = blobStartPosition;
                file.BlobEndPosition   = blobEndPosition;
                file.Deleted           = false;
                file.Size         = blobHeader.ContentLength;
                file.TimeCreated  = fileHeader.TimeCreated;
                file.TimeModified = fileHeader.TimeCreated;

                this.FileAdapter.UpdateFileTransparent(file);
            }
            else
            {
                if (file.Versions.Any(x => x.UniqueID == fileHeader.VersionUniqueID))
                {
                    throw new Exception(String.Format("Версия с идентификатором [{0}] уже существует.", fileHeader.VersionUniqueID.ToString()));
                }
            }

            //создание версии файла
            FileVersionMetadata version = new FileVersionMetadata(file);

            version.UniqueID          = fileHeader.VersionUniqueID;
            version.BlobID            = blobMetadata.ID;
            version.BlobStartPosition = blobStartPosition;
            version.BlobEndPosition   = blobEndPosition;
            version.Size             = blobHeader.ContentLength;
            version.TimeCreated      = fileHeader.TimeCreated;
            version.CreatedStorageID = storageMetadata.ID;
            version.Name             = fileHeader.FileName;

            //сохранение версии
            this.FileAdapter.VersionAdapter.InsertVerion(file, version);
            file.ResetVersions();

            //обновление параметров существующего файла
            if (!justCreated)
            {
                bool fileUpdate = false;
                if (version.TimeCreated > file.TimeModified)
                {
                    file.TimeModified    = version.TimeCreated;
                    file.VersionUniqueID = version.UniqueID;
                    file.BlobID          = version.BlobID;
                    fileUpdate           = true;
                }

                if (version.TimeCreated < file.TimeCreated)
                {
                    file.TimeCreated = version.TimeCreated;
                    fileUpdate       = true;
                }

                //обновление файла
                if (fileUpdate)
                {
                    this.FileAdapter.UpdateFileTransparent(file);
                }
            }

            return(file);
        }
示例#17
0
        private byte[] ReadContent(Guid fileUniqueID, Guid fileVersionUniqueID, long blobStartPosition, long blobEndPosition)
        {
            if (fileUniqueID == Guid.Empty)
            {
                throw new ArgumentNullException("fileUniqueID");
            }

            if (fileVersionUniqueID == Guid.Empty)
            {
                throw new ArgumentNullException("fileVersionUniqueID");
            }

            if (blobStartPosition < 0)
            {
                throw new ArgumentNullException("blobStartPosition");
            }

            if (blobEndPosition < 1)
            {
                throw new ArgumentNullException("blobEndPosition");
            }

            if (blobStartPosition >= blobEndPosition)
            {
                throw new Exception(string.Format("Индекс начала файла не может быть равным или больше индекса окончания файла"));
            }

            long length = blobEndPosition - blobStartPosition;

            if (blobEndPosition > this.BlobStream.Length)
            {
                throw new IndexOutOfRangeException("Индекс окончания файла превысил размер блоба");
            }

            //сырые данные файла (со всеми заголовками и хешами)
            byte[] rawData = new byte[length];
            if (length > Int32.MaxValue)
            {
                throw new Exception(string.Format("Файлы размером более 2GB в данный момент не поддерживаются"));
            }
            else
            {
                this.BlobStream.Seek(blobStartPosition, SeekOrigin.Begin);
                this.BlobStream.Read(rawData, 0, rawData.Length);
            }

            //1 - проверка системного префикса.
            //системный заголовок занимает первые _systemHeaderLength байт
            for (int i = 0; i < SystemHeaderFixedBytes.Length; i++)
            {
                if (SystemHeaderFixedBytes[i] != rawData[i])
                {
                    throw new Exception(string.Format("Битый заголовок файла (позиция {0}). Не удалось прочитать системный заголовок файла.",
                                                      i));
                }
            }

            //проверка заголовка.
            object          header     = this.GetFileHeader(rawData);
            IBlobFileHeader blobHeader = (IBlobFileHeader)header;

            long contentLength = blobHeader.ContentLength;

            if (contentLength == 0)
            {
                throw new Exception(string.Format("Не удалось считать размер содержимого файла"));
            }

            byte[] content = new byte[contentLength];
            Array.Copy(rawData, BlobStreamAdapter.SystemHeaderLength + blobHeader.HeaderLength, content, 0, contentLength);

            //проверка идентификаторов версий
            IFileHeader fileHeader = (IFileHeader)header;

            if (fileUniqueID != fileHeader.UniqueID)
            {
                throw new Exception(string.Format("Идентификатор файла в метаданных не совпадает с идентификатором файла в блобе"));
            }

            if (fileVersionUniqueID != fileHeader.VersionUniqueID)
            {
                throw new Exception(string.Format("Идентификатор версии файла в метаданных не совпадает с идентификатором версии файла в блобе"));
            }

            byte[] originalHeaderHash = new byte[16];//хеш заголовка файла из самого блоба
            Array.Copy(rawData, SystemHeaderFixedBytes.Length + BlobConsts.BlobFile.HeaderSizeBytesLength, originalHeaderHash, 0, originalHeaderHash.Length);
            //хеш вычисленный по байтам заголовка
            byte[] currentHeaderHash = this.HashAlgorithm.ComputeHash(rawData, BlobStreamAdapter.SystemHeaderLength, blobHeader.HeaderLength);
            bool   headerHashInvalid = !originalHeaderHash.SequenceEqual(currentHeaderHash);

            if (headerHashInvalid)
            {
                throw new Exception(string.Format("Битый заголовок файла. Не удалось прочитать системный заголовок файла."));
            }

            //3 - проверка хеша содержимого.
            byte[] originalContentHash = new byte[16];//хеш содержимого файла из самого блоба
            Array.Copy(rawData, SystemHeaderFixedBytes.Length + BlobConsts.BlobFile.HeaderSizeBytesLength + originalHeaderHash.Length, originalContentHash, 0, originalContentHash.Length);
            byte[] currentContentHash = this.HashAlgorithm.ComputeHash(content);
            bool   contentHashInvalid = !originalContentHash.SequenceEqual(currentContentHash);

            if (contentHashInvalid)
            {
                throw new Exception(string.Format("Битое содержимое файла. Не удалось прочитать содержимое файла."));
            }

            rawData             = null;
            originalHeaderHash  = null;
            currentHeaderHash   = null;
            originalContentHash = null;
            currentContentHash  = null;

            return(content);
        }
示例#18
0
        private static void WriteBlockStream(ICompressionAlgorithm compressionAlgorithm, IFileHeader header,
                                             DemoCustomHeader customHeader, MemoryStream ms, string s)
        {
            using (var blockStream = new BlockStream(compressionAlgorithm, ms, CompressionMode.Compress, true))
                using (var writer = new ExtendedBinaryWriter(blockStream))
                {
                    CheckReadException(blockStream);

                    blockStream.WriteHeader(header);

                    var bp = new BlockStream.BlockPosition();

                    // detect that we have written a block
                    blockStream.GetBlockPosition(bp);
                    int beforeBlockId = bp.Id;

                    writer.WriteOptAscii(s);

                    blockStream.GetBlockPosition(bp);
                    int afterBlockId = bp.Id;

                    Assert.NotEqual(beforeBlockId, afterBlockId);

                    // here we write a test string that won't invoke a new block
                    blockStream.GetBlockPosition(customHeader.DemoPosition);
                    beforeBlockId = customHeader.DemoPosition.Id;

                    writer.WriteOptAscii(SmallString);

                    blockStream.GetBlockPosition(bp);
                    afterBlockId = customHeader.DemoPosition.Id;

                    Assert.Equal(beforeBlockId, afterBlockId);
                    Assert.Equal(customHeader.DemoPosition.FileOffset, blockStream.Position);

                    blockStream.Flush();

                    // this will be flushed during dispose
                    writer.WriteOptAscii(FinalString);
                }
        }
示例#19
0
        public static GlobalCache CreateCache(IFileHeader header, List <TranscriptPacket> packets)
        {
            var builder = new TranscriptCacheBuilder(header, packets);

            return(builder.Create());
        }
示例#20
0
 public void WriteHeader(IFileHeader header)
 {
     _header = header;
     header.Write(_writer);
 }
        public void Restore()
        {
            //проверяем поочередно каждый блоб каждого контейнера
            foreach (IBlobContainerMetadata containerMetadata in this.Containers)
            {
                try
                {
                    //получаем все блобы контейнера
                    ICollection <IBlobMetadata> blobs = this.DataAdapter.BlobMetadataAdapter.GetBlobs(containerMetadata.ID);
                    if (blobs == null || blobs.Count == 0)
                    {
                        continue;
                    }

                    BlobContainer container = new BlobContainer(this.DataAdapter, containerMetadata);
                    //Алгоритм восстановления метаданных
                    //1 - получаем все блобы всех контейнеров
                    //нужно посмотреть все блобы и закрытие и открытые.
                    //потому что после запуска процедуры восстановления метаданных может пойти запись в не до конца восстановленный блоб
                    //и он станет закрытым, но восстановление не завершилось.

                    /*foreach (IBlobMetadata blobMetadata in blobs)
                     * {
                     *  object tmp = blobMetadata.Closed;
                     * }*/

                    //2 - для каждого блоба смотрим его позицию, до которой мы проверили целостность этого блоба
                    foreach (IBlobMetadata blobMetadata in blobs)
                    {
                        Blob blob = new Blob(container, blobMetadata);
                        try
                        {
                            long blobIntegrityPosition = blobMetadata.IntegrityPosition;
                            long filelenth             = blob.File.Length;

                            //целостность метаданных файлов блоба до конца проверена
                            while (blobIntegrityPosition < filelenth)
                            {
                                using (FileStream fs = blob.File.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                                {
                                    BlobStreamAdapter streamAdapter = new BlobStreamAdapter(fs);
                                    if (blobIntegrityPosition == 0)
                                    {
                                        //блоб может начинаться с системного заголовка.
                                        //а может с файла
                                        //тогда нужно сместить начальную позицию на этот системный заголовок
                                        //читаем позицию первого файла
                                        long firstFilePosition = streamAdapter.GetFirstFilePosition();
                                        blob.UpdateIntegrityPosition(firstFilePosition);
                                        blobIntegrityPosition = blobMetadata.IntegrityPosition;
                                    }


                                    //заголовок из файла
                                    object          fileHeaderObj  = streamAdapter.GetFileHeader(blobIntegrityPosition);
                                    IFileHeader     fileHeader     = (IFileHeader)fileHeaderObj;
                                    IBlobFileHeader blobFileHeader = (IBlobFileHeader)fileHeaderObj;

                                    long fileStartPosition = blobMetadata.IntegrityPosition;
                                    if (fileStartPosition != blobFileHeader.ContentAbsoluteStartPosition)
                                    {
                                        throw new Exception(string.Format("Позиция целостности блоба не соответствует позиции начала файла"));
                                    }

                                    long fileEndPosition = fileStartPosition
                                                           + BlobStreamAdapter.SystemHeaderLength
                                                           + blobFileHeader.HeaderLength
                                                           + blobFileHeader.ContentLength;

                                    //восстанавливаем метаданные, если их нет
                                    this.EnsureMetadata(blobMetadata, fileHeader, fileStartPosition, fileEndPosition);

                                    //увеличиваем позицию целостности метаданных блоба
                                    blob.UpdateIntegrityPosition(fileEndPosition);
                                    blobIntegrityPosition = blobMetadata.IntegrityPosition;
                                }
                            }
                        }
                        catch (Exception blobEx)
                        {
                            this.DataAdapter.Logger.WriteFormatMessage("Ошибка при восстановлении метаданных блоба с идентификатором {0} для контейнера {1}. Текст ошибки: {2}",
                                                                       blob.ID,
                                                                       containerMetadata.Path,
                                                                       blobEx);
                        }
                    }
                }
                catch (Exception containerEx)
                {
                    this.DataAdapter.Logger.WriteFormatMessage("Ошибка при восстановлении метаданных контейнера {0}. Текст ошибки: {1}",
                                                               containerMetadata.Path,
                                                               containerEx);
                }
            }
        }