private static void Main() { Logger.LogLevel = LoggingSettings.Settings.Level; var rootDir = LoggingSettings.Settings.DirPath; if (string.IsNullOrWhiteSpace(rootDir)) { rootDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); } var logEncoder = new XmlLogEncoder(); var byteWriter = new LazyStreamByteWriter(() => FileStreamFactory.CreateFileStream( Path.Combine(rootDir, Resources.SubdirectoryName))); Logger.AddLogWriter(new Lazy <ILogWriter>(() => new LogWriter(logEncoder, byteWriter))); // LogMsg message 1 Logger.Log(LogLevel.Error, "id-str1"); const string param = "param-str"; // LogMsg message 2 Logger.Log(LogLevel.Error, "id-str2", param, null); Fn(); }
void OpenFile() { if (!File.Exists(_filename)) { throw new Exception("file doesn't exists!"); } _filePtr = FileStreamFactory.CreateFileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferLength); _processedBytes = 0; }
private static byte[][] ReadLeafs(HashAlgorithm tg, string filePath, long start, long end) { using (ThreadUtility.EnterBackgroundProcessingMode()) using (var threadFilePtr = FileStreamFactory.CreateFileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 128 * 1024)) { var threadFileBlock = new FileBlock(start, end); var LeafSize = 1024; var DataBlockSize = LeafSize * 1024; var data = new byte[LeafSize + 1]; var totalLeafs = threadFileBlock.Length / LeafSize + threadFileBlock.Length % LeafSize > 0 ? 1 : 0; var result = new byte[totalLeafs][]; threadFilePtr.Position = threadFileBlock.Start; while (threadFilePtr.Position < threadFileBlock.End) { var leafIndex = (int)((threadFilePtr.Position - start) / 1024); var dataBlock = new byte[Math.Min(threadFileBlock.End - threadFilePtr.Position, DataBlockSize)]; threadFilePtr.Read(dataBlock, 0, dataBlock.Length); //read block var blockLeafs = dataBlock.Length / LeafSize; int i; for (i = 0; i < blockLeafs; i++) { Buffer.BlockCopy(dataBlock, i * LeafSize, data, 1, LeafSize); tg.Initialize(); result[leafIndex++] = tg.ComputeHash(data); } if (i * LeafSize < dataBlock.Length) { data = new byte[dataBlock.Length - blockLeafs * LeafSize + 1]; data[0] = LeafHash; Buffer.BlockCopy(dataBlock, blockLeafs * LeafSize, data, 1, (data.Length - 1)); tg.Initialize(); result[leafIndex] = tg.ComputeHash(data); data = new byte[LeafSize + 1]; data[0] = LeafHash; } } return(result); } }
void ProcessLeafs(object threadId) { using (LowPriority ? ThreadUtility.EnterBackgroundProcessingMode() : null) using (var threadFilePtr = FileStreamFactory.CreateFileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferLength)) { var threadFileBlock = _fileParts[(int)threadId]; var tg = new T(); var data = new byte[LeafSize + 1]; threadFilePtr.Position = threadFileBlock.Start; var dataBlock = new byte[DataBlockSize]; while (threadFilePtr.Position < threadFileBlock.End) { var leafIndex = (int)(threadFilePtr.Position / 1024); var dataBlockSize = (int)Math.Min(threadFileBlock.End - threadFilePtr.Position, DataBlockSize); threadFilePtr.Read(dataBlock, 0, dataBlockSize); //read block Interlocked.Add(ref _processedBytes, dataBlockSize); var blockLeafs = dataBlockSize / 1024; int i; for (i = 0; i < blockLeafs; i++) { Buffer.BlockCopy(dataBlock, i * LeafSize, data, 1, LeafSize); tg.Initialize(); TTH[0][leafIndex++] = tg.ComputeHash(data); } if (i * LeafSize < dataBlockSize) { data = new byte[dataBlockSize - blockLeafs * LeafSize + 1]; data[0] = LeafHash; Buffer.BlockCopy(dataBlock, blockLeafs * LeafSize, data, 1, (data.Length - 1)); tg.Initialize(); TTH[0][leafIndex] = tg.ComputeHash(data); data = new byte[LeafSize + 1]; data[0] = LeafHash; } } } }
private async Task <long> InternalCopyChunk(Stream stream, long filePos, int bytesRequired) { if (_fileStream == null) { FileStream fs; using (new PerfLimit("Slow open " + Content.SystemPath, 4000)) { fs = FileStreamFactory.CreateFileStream(SystemPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, FileStreamReadBufferSize, FileOptions.Asynchronous); } lock (_syncRoot) { if (_isDisposed) { fs.Dispose(); return(0); } _fileStream = fs; } Interlocked.Increment(ref _fileStreamsCount); } _fileStream.Position = filePos; long readSoFar = 0L; var buffer = new byte[FileStreamReadBufferSize]; do { var toRead = Math.Min(bytesRequired - readSoFar, buffer.Length); var readNow = await _fileStream.ReadAsync(buffer, 0, (int)toRead).ConfigureAwait(false); if (readNow == 0) { break; // End of stream } await stream.WriteAsync(buffer, 0, readNow).ConfigureAwait(false); readSoFar += readNow; Interlocked.Add(ref _uploadedBytes, readNow); } while (readSoFar < bytesRequired); return(readSoFar); }
public static void Replicate(string sourcefileStorageName, string targetfileStorageName, ReplicateBehaviour replicateBehaviour, AddFileBehaviour addFileBehaviour, FileStorageHandler.ExposeProgressDelegate exposeProgressDelegatePhase1, FileStorageHandler.ExposeProgressDelegate exposeProgressDelegatePhase2) { var sourceFileStorageHandler = FileStorageHandler.Open(sourcefileStorageName); switch (replicateBehaviour) { case ReplicateBehaviour.AddToExistingStorage: // // nothing to check here // break; case ReplicateBehaviour.ReplicateToNewStorage: // // ensure target does not yet exist // Create(targetfileStorageName, CreateFileStorageBehaviour.ThrowExceptionWhenExists); break; default: throw new NotSupportedException(string.Format("Unsupported replicate behaviour {0}", replicateBehaviour)); } var targetFileStorageHandler = FileStorageHandler.Open(targetfileStorageName); // // open source streams // using (sourceFileStorageHandler.indexStream = FileStreamFactory.CreateFileStream(sourceFileStorageHandler.indexFilename, StreamStateBehaviour.OpenNewStreamForReading)) { using (sourceFileStorageHandler.dataStream = FileStreamFactory.CreateFileStream(sourceFileStorageHandler.dataFilename, StreamStateBehaviour.OpenNewStreamForReading)) { // // open target streams // using (targetFileStorageHandler.indexStream = FileStreamFactory.CreateFileStream(targetFileStorageHandler.indexFilename, StreamStateBehaviour.OpenNewStreamForReadingAndWriting)) { using (targetFileStorageHandler.dataStream = FileStreamFactory.CreateFileStream(targetFileStorageHandler.dataFilename, StreamStateBehaviour.OpenNewStreamForReadingAndWriting)) { var allIdentifiers = sourceFileStorageHandler.GetAllDataIdentifiersBasedUponFileStorageIndexFile(StreamStateBehaviour.UseExistingStream, exposeProgressDelegatePhase1); // // start replicate process // foreach (var dataIdentifier in allIdentifiers) { sourceFileStorageHandler.ExportToOtherFileStorage(dataIdentifier, targetFileStorageHandler, addFileBehaviour, StreamStateBehaviour.UseExistingStream, StreamStateBehaviour.UseExistingStream, StreamStateBehaviour.UseExistingStream, StreamStateBehaviour.UseExistingStream); if (exposeProgressDelegatePhase2 != null) { exposeProgressDelegatePhase2.Invoke(dataIdentifier); } } if (exposeProgressDelegatePhase2 != null) { exposeProgressDelegatePhase2.Invoke(true); } } } } } }