public void GetAllFileNamesWhenThereNoFiles()
{
var results = FileStreamer.GetAllFileNames("Test", "Test");
Assert.IsNotNull(results);
Assert.IsEmpty(results);
}
public async Task UndeleteWhenFileExists()
{
MockFile.Setup(x => x.Exists(Filename + ".deleted")).ReturnsAsync(true);
await FileStreamer.Undelete(Filename);
MockFile.Verify(x => x.Move(Filename + ".deleted", Filename), Times.Once);
}
public async Task UnlockFileWhenThereIsNoLock()
{
await FileStreamer.UnlockFile(Filename);
MockSemaphoreFactory.Verify(x => x.Create(1, 1), Times.Never);
MockSemaphore.Verify(x => x.Release(), Times.Never);
}
public async Task <AuditLog> ReadAllEvents <TDataType>(int id) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} for {DataType} with id ({id})", nameof(FileAuditWorker),
"reading all events", typeof(TDataType).Name, id))
{
var filename = GetFileName <TDataType>(id);
if (!await FileStreamer.Exists(filename))
{
return(null);
}
var maxAttempts = MaxAttempts <TDataType>();
_logger.LogTrace("Will try to write to {filename} {MaxAttempts} times", filename,
maxAttempts >= 0 ? maxAttempts.ToString() : "until success");
var attempts = 0;
while (maxAttempts == -1 || attempts < maxAttempts)
{
attempts++;
_logger.LogTrace("Attempt number {Attempt}", attempts);
if (await FileStreamer.GetLockForFile(filename))
{
try
{
var audit = await FileStreamer.ReadDataFromStream <AuditLog>(filename);
_logger.LogInformation("Read audit from disk");
return(audit);
}
catch (Exception exception)
{
_logger.LogWarning(exception, "Failed to read audit");
}
}
public async Task <bool> Commit <TDataType>(int id) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(FileDataWorker),
"commiting data", typeof(TDataType).Name, id))
{
var filename = GetFileName <TDataType>(id);
var maxAttempts = MaxAttempts <TDataType>();
_logger.LogTrace("Will try to write to {filename} {MaxAttempts} times", filename, maxAttempts);
var attempts = 0;
while (attempts < maxAttempts)
{
attempts++;
_logger.LogTrace("Attempt number {Attempt}", attempts);
try
{
if (await FileStreamer.CloseStream(filename))
{
_logger.LogInformation("Closed the file and committed the data to disk");
await FileStreamer.UnlockFile(filename);
return(true);
}
}
catch (Exception exception)
{
_logger.LogWarning(exception, "Failed to commit data to disk as an error happened");
}
}
_logger.LogError("Failed to commit data to disk");
await DiscardChanges <TDataType>(id);
return(false);
}
}
public async Task <bool> GetLockForFileWaitSuccess()
{
var result = FileStreamer.GetLockForFile(Filename);
MockSemaphoreFactory.Verify(x => x.Create(1, 1), Times.Once);
return(await result);
}
public async Task <TDataType> Read <TDataType>(int id) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(FileDataWorker),
"reading", typeof(TDataType).Name, id))
{
var filename = GetFileName <TDataType>(id);
var maxAttempts = MaxAttempts <TDataType>();
_logger.LogTrace("Will try to read from {filename} {MaxAttempts} times", filename, maxAttempts);
var attempts = 0;
while (attempts < maxAttempts)
{
attempts++;
_logger.LogTrace("Attempt number {Attempt}", attempts);
if (await FileStreamer.GetLockForFile(filename))
{
try
{
_logger.LogTrace("Got lock on file");
return(await FileStreamer.ReadDataFromStream <TDataType>(filename));
}
catch (Exception exception)
{
_logger.LogWarning(exception, "Failed to read data as an error happened");
}
}
static void Main(string[] args)
{
var path = Directory.GetCurrentDirectory();
var pathInput = $"{path}\\Input.txt";
var fs = new FileStreamer();
var conferenceTalkList = fs.FileReader(pathInput);
var converter = new Converter();
var conferenceActivityList = new List <Activity>();
conferenceActivityList = converter.ConvertToActivityListFrom(conferenceTalkList);
var orderList = new List <Activity>();
orderList = converter.GetOrderedActivityListFrom(conferenceActivityList);
var scheduler = new Scheduler();
var tracksList = new List <Track>();
tracksList = scheduler.CreateTracksListFrom(orderList);
foreach (var track in tracksList)
{
track.ActivityList = converter.GetOrderedDateTimeListFrom(track.ActivityList);
}
var pathOutput = $"{path}\\Output.txt";
fs.FileWriter(tracksList, pathOutput);
}
public async Task <bool> ExistsWhenItDoesNotExist()
{
MockFile
.Setup(x => x.Exists(Filename))
.ReturnsAsync(false);
return(await FileStreamer.Exists(Filename));
}
public async Task ReadDataFromStreamMultipleTimes()
{
await FileStreamer.ReadDataFromStream <BasicData>(Filename);
Assert.AreSame(Data, await FileStreamer.ReadDataFromStream <BasicData>(Filename));
MockFile.Verify(x => x.OpenRead(Filename), Times.Exactly(2));
MockMessagePackSerializer.Verify(x => x.Deserialize <BasicData>(ReadStream), Times.Exactly(2));
}
public async Task ReadDataFromStreamNewStreamNeeded()
{
Assert.AreSame(Data, await FileStreamer.ReadDataFromStream <BasicData>(Filename));
MockFile.Verify(x => x.OpenRead(Filename), Times.Once);
MockReadStream.Verify(x => x.Close(), Times.Once);
MockReadStream.Verify(x => x.Dispose(), Times.Once);
MockMessagePackSerializer.Verify(x => x.Deserialize <BasicData>(ReadStream), Times.Once);
}
public async Task <bool> WriteDataToStreamNewStreamNeeded()
{
var result = FileStreamer.WriteDataToStream(Filename, Data);
MockFile.Verify(x => x.OpenWrite(Filename), Times.Once);
MockMessagePackSerializer.Verify(x => x.Serialize(WriteStream, Data), Times.Once);
return(await result);
}
public Task <bool> IndexExist <TDataType>(string indexName) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} {IndexName} for {DataType}", nameof(FileIndexWorker),
"checking existence of", indexName, typeof(TDataType).Name))
{
return(FileStreamer.Exists(GetFileName <TDataType>(indexName)));
}
}
private void ReadFile()
{
var fs = new FileStreamer(Directory, WordFilename);
WordList = fs.ReadByLine();
fs.FileName = LookUpFilename;
LookUpText = fs.ReadAllText();
}
public async Task <bool> GetLockForFileWaitFails()
{
MockSemaphore
.Setup(x => x.Wait(It.Is <TimeSpan>(y => Math.Abs(y.TotalMinutes - 1) < 1)))
.Returns(false);
var result = FileStreamer.GetLockForFile(Filename);
MockSemaphoreFactory.Verify(x => x.Create(1, 1), Times.Once);
return(await result);
}
public async Task <bool> WriteDataToStreamMultipleTimes()
{
await FileStreamer.WriteDataToStream(Filename, Data);
var result = FileStreamer.WriteDataToStream(Filename, Data);
MockFile.Verify(x => x.OpenWrite(Filename), Times.Once);
MockMessagePackSerializer.Verify(x => x.Serialize(WriteStream, Data), Times.Exactly(2));
return(await result);
}
public async Task <bool> CloseStreamWhenThereIsNoStream()
{
var result = FileStreamer.CloseStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockReadStream
.Verify(x => x.Close(), Times.Never);
return(await result);
}
public async Task UnlockFileWhenThereIsALockMultipleTimes()
{
await FileStreamer.GetLockForFile(Filename);
await FileStreamer.UnlockFile(Filename);
await FileStreamer.UnlockFile(Filename);
MockSemaphoreFactory.Verify(x => x.Create(1, 1), Times.Once);
MockSemaphore.Verify(x => x.Release(), Times.Exactly(2));
}
public async Task DisposeOfStreamWhenThereIsNoStream()
{
await FileStreamer.DisposeOfStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockReadStream
.Verify(x => x.Dispose(), Times.Never);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockReadStream
.Verify(x => x.Dispose(), Times.Never);
}
public async Task DiscardEvents <TDataType>(TDataType data) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} for {DataType}", nameof(FileAuditWorker),
"discarded events", typeof(TDataType).Name))
{
var filename = GetFileName <TDataType>(data.Id);
_logger.LogTrace("Discarding changes for {filename}", filename);
await FileStreamer.DisposeOfStream(filename);
await FileStreamer.UnlockFile(filename);
_logger.LogInformation("Discarded changes for {filename}", filename);
}
}
public async Task DiscardChanges <TDataType>(int id) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(FileDataWorker),
"discarding changes", typeof(TDataType).Name, id))
{
var filename = GetFileName <TDataType>(id);
_logger.LogTrace("Discarding changes to file {filename}", filename);
await FileStreamer.DisposeOfStream(filename);
await FileStreamer.UnlockFile(filename);
_logger.LogInformation("Discarded changes to file");
}
}
public async Task DisposeOfStreamWhenThereIsAReadStream()
{
await FileStreamer.ReadDataFromStream <BasicData>(Filename);
await FileStreamer.DisposeOfStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockWriteStream
.Verify(x => x.Dispose(), Times.Never);
MockReadStream
.Verify(x => x.Close(), Times.Once);
MockReadStream
.Verify(x => x.Dispose(), Times.Once);
}
public async Task <bool> CloseStreamWhenThereIsAWriteStream()
{
await FileStreamer.WriteDataToStream(Filename, Data);
var result = FileStreamer.CloseStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Once);
MockWriteStream
.Verify(x => x.Dispose(), Times.Once);
MockReadStream
.Verify(x => x.Close(), Times.Never);
MockReadStream
.Verify(x => x.Dispose(), Times.Never);
return(await result);
}
public void Setup()
{
Filename = Randomizer.CreateRandomizer().GetString();
Data = new BasicData();
WriteStream = new MemoryStream();
ReadStream = new MemoryStream();
MockWriteStream = new Mock <IStream>();
MockWriteStream
.Setup(x => x.GetStream())
.Returns(WriteStream);
MockReadStream = new Mock <IStream>();
MockReadStream
.Setup(x => x.GetStream())
.Returns(ReadStream);
MockMessagePackSerializer = new Mock <IMessagePackSerializer>();
MockMessagePackSerializer
.Setup(x => x.Deserialize <BasicData>(ReadStream))
.ReturnsAsync(Data);
MockFile = new Mock <IFile>();
MockFile
.Setup(x => x.OpenWrite(Filename))
.ReturnsAsync(MockWriteStream.Object);
MockFile
.Setup(x => x.OpenRead(Filename))
.ReturnsAsync(MockReadStream.Object);
MockFile
.Setup(x => x.Exists(Filename))
.ReturnsAsync(true);
MockSemaphore = new Mock <ISemaphore>();
MockSemaphore
.Setup(x => x.Wait(It.Is <TimeSpan>(y => Math.Abs(y.TotalMinutes - 1.0) < 1)))
.Returns(true);
MockSemaphoreFactory = new Mock <ISemaphoreFactory>();
MockSemaphoreFactory
.Setup(x => x.Create(1, 1))
.Returns(MockSemaphore.Object);
MockDirectory = new Mock <IDirectory>();
FileStreamer = new FileStreamer(MockMessagePackSerializer.Object, MockFile.Object,
MockSemaphoreFactory.Object, MockDirectory.Object);
}
public async Task DisposeOfStreamWhenThereIsAWriteStreamIsAlreadyDisposed()
{
await FileStreamer.WriteDataToStream(Filename, Data);
await FileStreamer.DisposeOfStream(Filename);
await FileStreamer.DisposeOfStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockWriteStream
.Verify(x => x.Dispose(), Times.Once);
MockReadStream
.Verify(x => x.Close(), Times.Never);
MockReadStream
.Verify(x => x.Dispose(), Times.Never);
}
public async Task <bool> CloseStreamWhenThereIsAReadStreamIsAlreadyClosed()
{
await FileStreamer.ReadDataFromStream <BasicData>(Filename);
await FileStreamer.CloseStream(Filename);
var result = FileStreamer.CloseStream(Filename);
MockWriteStream
.Verify(x => x.Close(), Times.Never);
MockWriteStream
.Verify(x => x.Dispose(), Times.Never);
MockReadStream
.Verify(x => x.Close(), Times.Once);
MockReadStream
.Verify(x => x.Dispose(), Times.Once);
return(await result);
}
/// <summary>
/// Load list of user from file
/// </summary>
/// <param name="file">path to file</param>
public void LoadUsers(string file)
{
try
{
List <User> tmp = FileStreamer <User> .BinLoad(file);
if (tmp != null)
{
_users = tmp;
}
}
catch (Exception e)
{
FileStreamer <User> .CreateFile(file);
Console.Out.WriteLine(e);
}
}
public void GetAllFileNamesWhenAreFiles()
{
MockDirectory
.Setup(x => x.GetFiles("Test", "Test"))
.Returns(new List <string>
{
"Test1",
"Test\\Test2",
"Test\\Test3.Test"
}.ToArray());
var results = FileStreamer.GetAllFileNames("Test", "Test");
Assert.IsNotNull(results);
Assert.IsNotEmpty(results);
Assert.AreEqual(3, results.Count());
Assert.AreEqual("Test1", results[0]);
Assert.AreEqual("Test2", results[1]);
Assert.AreEqual("Test3", results[2]);
}
public async IAsyncEnumerable <IndexKey <TKeyType> > GetKeysFromIndex <TDataType, TKeyType>(string indexName) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} {IndexName} for {DataType}}",
nameof(FileIndexWorker), "getting keys from index", indexName, typeof(TDataType).Name))
{
var index = await FileStreamer.ReadDataFromStream <Index <TKeyType> >(GetFileName <TDataType>(indexName));
var keys = index.Keys;
if (keys == null)
{
_logger.LogWarning("The index doesn't have the keys");
yield break;
}
foreach (var key in keys)
{
_logger.LogInformation("Returning {KeyValue}", key.Value, key);
yield return(key);
}
}
}
public async Task <bool> CommitEvents <TDataType>(TDataType data) where TDataType : DataEntity
{
using (_logger.BeginScope("{Operation} is {Action} for {DataType}", nameof(FileAuditWorker),
"committing events", typeof(TDataType).Name))
{
var filename = GetFileName <TDataType>(data.Id);
var maxAttempts = MaxAttempts <TDataType>();
_logger.LogTrace("Will try to write to {filename} {MaxAttempts} times", filename,
maxAttempts >= 0 ? maxAttempts.ToString() : "until success");
var attempts = 0;
while (maxAttempts == -1 || attempts < maxAttempts)
{
attempts++;
_logger.LogTrace("Attempt number {Attempt}", attempts);
try
{
_logger.LogTrace("Closing audit file");
if (await FileStreamer.CloseStream(filename))
{
_logger.LogTrace("Closed audit file");
await FileStreamer.UnlockFile(filename);
_logger.LogInformation("Committed audit to file");
return(true);
}
_logger.LogWarning("Failed to close audit file");
}
catch (Exception exception)
{
_logger.LogWarning(exception, "Failed to commit audit");
}
}
await DiscardEvents(data);
_logger.LogWarning("Discarded events after max attempts trying to commit audit");
return(false);
}
}
public FileContentResult DownloadDemoClip(string clipId)
{
IMyMentorRepository repository = new ParseRepository(new WebCacheProvider(HttpContext.ApplicationInstance.Context));
var clipUrl = repository.FindDemoClipURI(clipId);
var streamer = new FileStreamer(HttpContext);
var stream = streamer.GetTempFileUrl(clipUrl);
return File(stream, "audio/mpeg3");
}
