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);
}
}
}
}
}
}
