public async Task MediaPropertiesMustChangeOnlyAfterUpdate()
{
IFileSystem fs = Substitute.For <IFileSystem>();
MyFileStream stm = Substitute.For <MyFileStream>(new object());
fs.OpenFile("test").Returns(stm);
DateTime time1 = new DateTime(2000, 1, 1);
long size1 = 100;
stm.Length.Returns(size1);
stm.LastWriteTime.Returns(time1);
stm.IsDeleted.Returns(false);
using (SimpleFileMedia media = await SimpleFileMedia.Create(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
// Media properties are the same as stm's ones
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
// Change the properties of stm
DateTime time2 = new DateTime(2000, 2, 2);
long size2 = 200;
stm.Length.Returns(size2);
stm.LastWriteTime.Returns(time2);
stm.IsDeleted.Returns(false);
// Properties have not still changed
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
// This Update should refresh media's properties
await media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
// Subsequent calls change nothing
await media.Update();
await media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
}
stm.Received(1).Dispose();
}
public void UpdatingWhileFileIsGrowing()
{
IFileSystem fs = Substitute.For <IFileSystem>();
MyFileStream stm = Substitute.For <MyFileStream>(new object());
fs.OpenFile("test").Returns(stm);
DateTime time1 = new DateTime(2000, 1, 1);
long size1 = 100;
stm.Length.Returns(size1);
stm.LastWriteTime.Returns(time1);
stm.IsDeleted.Returns(false);
using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
Assert.AreEqual(size1, media.DataStream.Length);
DateTime time2 = new DateTime(2000, 2, 2);
long size2 = 200;
stm.Length.Returns(size2);
stm.LastWriteTime.Returns(time2);
stm.IsDeleted.Returns(false);
media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
}
stm.Received(1).Dispose();
}
public void UpdatingWhileFileIsGrowing()
{
MockRepository rep = new MockRepository();
IFileSystem fs = rep.CreateMock <IFileSystem>();
MyFileStream stm = rep.CreateMock <MyFileStream>(rep);
Expect.Call(fs.OpenFile("test")).Return(stm);
DateTime time1 = new DateTime(2000, 1, 1);
long size1 = 100;
Expect.Call(stm.Length).Repeat.Any().Return(size1);
Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time1);
Expect.Call(stm.IsDeleted).Repeat.Any().Return(false);
rep.ReplayAll();
using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
Assert.AreEqual(size1, media.DataStream.Length);
rep.VerifyAll();
rep.BackToRecordAll();
DateTime time2 = new DateTime(2000, 2, 2);
long size2 = 200;
Expect.Call(stm.Length).Repeat.Any().Return(size2);
Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time2);
Expect.Call(stm.IsDeleted).Repeat.Any().Return(false);
rep.ReplayAll();
media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
rep.VerifyAll();
rep.BackToRecordAll();
stm.Dispose();
LastCall.On(stm).Repeat.AtLeastOnce();
rep.ReplayAll();
}
rep.VerifyAll();
}
public void FileDeletedByAnotherProcessAndThenNewFileAppeared()
{
IFileSystem fs = Substitute.For <IFileSystem>();
// Create and init the first stream
long initialSize1 = 100;
DateTime modifTime1 = new DateTime(2000, 3, 4);
MyFileStream stm1 = Substitute.For <MyFileStream>(new object());
stm1.Length.Returns(initialSize1);
stm1.IsDeleted.Returns(false);
stm1.LastWriteTime.Returns(modifTime1);
// Instruct file system to return the first stream
fs.OpenFile("test").Returns(stm1);
MyFileStream stm2 = Substitute.For <MyFileStream>(new object());
using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
// Check that media refers to the first stream stm1
Assert.AreEqual(initialSize1, media.DataStream.Length);
Assert.AreEqual(initialSize1, media.Size);
Assert.AreEqual(true, media.IsAvailable);
// Simulate file deletion: Length and LastWriteTime keep returning file properties,
// but IsDeleted now returns "true".
stm1.IsDeleted.Returns(true);
// Factory cannot open the file that has been deleted while being locked
fs.OpenFile("test").Returns(
_ => throw new UnauthorizedAccessException(),
_ => throw new UnauthorizedAccessException(),
_ => stm2
);
// Properties must return previous values as long as Update is not called
Assert.AreEqual(initialSize1, media.Size);
Assert.AreEqual(initialSize1, media.DataStream.Length);
Assert.AreEqual(true, media.IsAvailable);
// This update should detect file deletion and release it
media.Update();
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
stm1.Received(1).Dispose();
// Subsequent Updates should change nothing
media.Update();
media.Update();
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
// Simulate that new file with name "test" appeared
long initialSize2 = 200;
DateTime modifTime2 = new DateTime(2000, 4, 5);
stm2.Length.Returns(initialSize2);
stm2.IsDeleted.Returns(false);
stm2.LastWriteTime.Returns(modifTime2);
// Properties must return previous values as long as Update is not called
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
// This Update will pick up new file
media.Update();
Assert.AreEqual(initialSize2, media.DataStream.Length);
Assert.AreEqual(initialSize2, media.Size);
Assert.AreEqual(true, media.IsAvailable);
// Subsequent Updates should change nothing
media.Update();
media.Update();
Assert.AreEqual(initialSize2, media.Size);
Assert.AreEqual(initialSize2, media.DataStream.Length);
Assert.AreEqual(true, media.IsAvailable);
}
stm2.Received(1).Dispose();
}
protected override void LiveLogListen(CancellationToken stopEvt, LiveLogXMLWriter output)
{
using (ILogMedia media = new SimpleFileMedia(
LogMedia.FileSystemImpl.Instance,
SimpleFileMedia.CreateConnectionParamsFromFileName(fileName)))
using (FileSystemWatcher watcher = new FileSystemWatcher(Path.GetDirectoryName(fileName),
Path.GetFileName(fileName)))
using (AutoResetEvent fileChangedEvt = new AutoResetEvent(true))
{
IMessagesSplitter splitter = new MessagesSplitter(
new StreamTextAccess(media.DataStream, Encoding.ASCII, TextStreamPositioningParams.Default),
RegexFactory.Instance.Create(@"^(?<body>.+)$", ReOptions.Multiline)
);
watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size;
watcher.Changed += delegate(object sender, FileSystemEventArgs e)
{
fileChangedEvt.Set();
};
//watcher.EnableRaisingEvents = true;
long lastLinePosition = 0;
long lastStreamLength = 0;
WaitHandle[] events = new WaitHandle[] { stopEvt.WaitHandle, fileChangedEvt };
var capture = new TextMessageCapture();
for (; ;)
{
if (WaitHandle.WaitAny(events, 250, false) == 0)
{
break;
}
media.Update();
if (media.Size == lastStreamLength)
{
continue;
}
lastStreamLength = media.Size;
sizeInBytesStat = lastStreamLength;
DateTime lastModified = media.LastModified;
splitter.BeginSplittingSession(new FileRange.Range(0, lastStreamLength), lastLinePosition, MessagesParserDirection.Forward);
try
{
for (; ;)
{
if (!splitter.GetCurrentMessageAndMoveToNextOne(capture))
{
break;
}
lastLinePosition = capture.BeginPosition;
XmlWriter writer = output.BeginWriteMessage(false);
writer.WriteStartElement("m");
writer.WriteAttributeString("d", Listener.FormatDate(lastModified));
writer.WriteString(XmlUtils.RemoveInvalidXMLChars(capture.MessageHeader));
writer.WriteEndElement();
output.EndWriteMessage();
}
}
finally
{
splitter.EndSplittingSession();
}
}
}
}
public void MediaPropertiesMustChangeOnlyAfterUpdate()
{
MockRepository rep = new MockRepository();
IFileSystem fs = rep.CreateMock <IFileSystem>();
MyFileStream stm = rep.CreateMock <MyFileStream>(rep);
Expect.Call(fs.OpenFile("test")).Return(stm);
DateTime time1 = new DateTime(2000, 1, 1);
long size1 = 100;
Expect.Call(stm.Length).Repeat.Any().Return(size1);
Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time1);
Expect.Call(stm.IsDeleted).Repeat.Any().Return(false);
rep.ReplayAll();
using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
// Media properties are the same as stm's ones
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
rep.VerifyAll();
rep.BackToRecordAll();
// Chnage the properties of stm
DateTime time2 = new DateTime(2000, 2, 2);
long size2 = 200;
Expect.Call(stm.Length).Repeat.Any().Return(size2);
Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time2);
Expect.Call(stm.IsDeleted).Repeat.Any().Return(false);
rep.ReplayAll();
// Properties have not still changed
Assert.AreEqual(time1, media.LastModified);
Assert.AreEqual(size1, media.Size);
// This Update should refresh media's properties
media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
// Subsequent calls change nothing
media.Update();
media.Update();
Assert.AreEqual(time2, media.LastModified);
Assert.AreEqual(size2, media.Size);
rep.VerifyAll();
rep.BackToRecordAll();
stm.Dispose();
LastCall.On(stm).Repeat.AtLeastOnce();
rep.ReplayAll();
}
rep.VerifyAll();
}
public void FileDeletedByAnotherProcessAndThenNewFileAppeared()
{
MockRepository rep = new MockRepository();
IFileSystem fs = rep.CreateMock <IFileSystem>();
// Create and init the first stream
long initialSize1 = 100;
DateTime modifTime1 = new DateTime(2000, 3, 4);
MyFileStream stm1 = rep.CreateMock <MyFileStream>(rep);
Expect.Call(stm1.Length).Repeat.Any().Return(initialSize1);
Expect.Call(stm1.IsDeleted).Repeat.Any().Return(false);
Expect.Call(stm1.LastWriteTime).Repeat.Any().Return(modifTime1);
// Instruct file system to return the first stream
Expect.Call(fs.OpenFile("test")).Return(stm1);
rep.ReplayAll();
using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test")))
{
// Check that media refers to the first stream stm1
Assert.AreEqual(initialSize1, media.DataStream.Length);
Assert.AreEqual(initialSize1, media.Size);
Assert.AreEqual(true, media.IsAvailable);
rep.VerifyAll();
rep.BackToRecordAll();
// Simulate file deletion: Length and LastWriteTime keep returning file properties,
// but IsDeleted now returns "true".
Expect.Call(stm1.Length).Repeat.Any().Return(initialSize1);
Expect.Call(stm1.LastWriteTime).Repeat.Any().Return(modifTime1);
Expect.Call(stm1.IsDeleted).Repeat.Any().Return(true);
// We expect stream stm1 to be released/disposed
stm1.Dispose();
LastCall.On(stm1).Repeat.AtLeastOnce();
// Factory cannot open the file that has been deleted while being locked
Expect.Call(fs.OpenFile("test")).Repeat.Any().Throw(new UnauthorizedAccessException());
rep.ReplayAll();
// Properties must return previous values as long as Update is not called
Assert.AreEqual(initialSize1, media.Size);
Assert.AreEqual(initialSize1, media.DataStream.Length);
Assert.AreEqual(true, media.IsAvailable);
// This update should detect file deletion and release it
media.Update();
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
// Subsequent Updates should change nothing
media.Update();
media.Update();
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
rep.VerifyAll();
rep.BackToRecordAll();
// Simulate that new file with name "test" appeared
long initialSize2 = 200;
DateTime modifTime2 = new DateTime(2000, 4, 5);
MyFileStream stm2 = rep.CreateMock <MyFileStream>(rep);
Expect.Call(stm2.Length).Repeat.Any().Return(initialSize2);
Expect.Call(stm2.IsDeleted).Repeat.Any().Return(false);
Expect.Call(stm2.LastWriteTime).Repeat.Any().Return(modifTime2);
stm2.Dispose();
LastCall.On(stm2).Repeat.AtLeastOnce();
Expect.Call(fs.OpenFile("test")).Return(stm2);
rep.ReplayAll();
// Properties must return previous values as long as Update is not called
Assert.AreEqual(0, media.Size);
Assert.AreEqual(0, media.DataStream.Length);
Assert.AreEqual(false, media.IsAvailable);
// This Update will pick up new file
media.Update();
Assert.AreEqual(initialSize2, media.DataStream.Length);
Assert.AreEqual(initialSize2, media.Size);
Assert.AreEqual(true, media.IsAvailable);
// Subsequent Updates should change nothing
media.Update();
media.Update();
Assert.AreEqual(initialSize2, media.Size);
Assert.AreEqual(initialSize2, media.DataStream.Length);
Assert.AreEqual(true, media.IsAvailable);
}
rep.VerifyAll();
}
