protected override void PrepareCatalogue(Catalogue catalogue)
{
// Check that the file exists.
if (File.Exists(InitialisationString))
{
// Create a catalogue reader for the file.
IRepositoryReader reader = CreateReader();
CatalogueCopier.Copy(catalogue, reader.Read(), ReadOnlyOption.Clear);
}
}
private void ConnectInternal()
{
EnsureRepositoryLink();
IRepositoryReader reader = m_repositoryLink.GetConnection <IRepositoryReader>();
if (reader != null)
{
using (ConnectionState state = new ConnectionState())
{
m_catalogue = reader.Read(state);
}
}
}
private static Catalogue GetCatalogue(IUnityContainer container)
{
const string method = "GetCatalogue";
IRepositoryReader repositoryReader = null;
Catalogue catalogue = null;
try
{
// Access the current catalogue.
repositoryReader = container.Resolve <IRepositoryReader>();
catalogue = repositoryReader.Read();
_errorGettingCatalogue = null;
}
catch (Exception ex)
{
_errorGettingCatalogue = ex;
_internalMessageHandler.HandleEventMessage(new EventMessage(null, Event.Error, typeof(InstrumentationManager), method,
string.Format("Failed to initialise the current catalogue for the Instrumentation module: {0}{1}", Environment.NewLine, ex)));
}
try
{
if (catalogue != null)
{
// Register for callbacks.
var repositoryUpdate = repositoryReader as IRepositoryUpdate;
if (repositoryUpdate != null)
{
repositoryUpdate.RegisterCallback(RepositoryCallback);
}
}
}
catch (Exception ex)
{
_internalMessageHandler.HandleEventMessage(new EventMessage(null, Event.Warning, typeof(InstrumentationManager), method,
string.Format("Failed to register an Instrumentation repository callback for repository"
+ " in process {0}, running as user '{1}\\{2}'. Instrumentation will still be initialised,"
+ " but configuration changes will have no effect until the process is restarted.{3}{4}",
Process.GetCurrentProcess().Id, Environment.UserDomainName, Environment.UserName,
Environment.NewLine, ex)));
}
return(catalogue);
}
private void CheckAllDataInFolder(IRepositoryFolder folder, IDataItem[] expectedData)
{
List <IDataItem> dataRead = new List <IDataItem>(expectedData.Length);
using (IRepositoryReader reader = folder.GetReader(DateTime.MinValue, true))
{
while (reader.HasData)
{
dataRead.Add(reader.Read().DataItem);
}
}
Assert.AreEqual(expectedData.Length, dataRead.Count, "The total number of items read after writing does not match the amount written");
for (int n = 0; n < expectedData.Length; ++n)
{
Assert.AreEqual(expectedData[n], dataRead[n]);
}
}
public void QuickReaderTest()
{
string targetFolderName = "QuickReaderTest";
IRepositoryFolder targetFolder = FixtureRootRepoFolder.GetSubFolder(targetFolderName);
if (targetFolder != null)
{
targetFolder.Delete(true, true);
}
targetFolder = FixtureRootRepoFolder.CreateSubfolder(targetFolderName);
string targetFolderPath = targetFolder.FullPath;
const int subfolderCount = 3;
const int itemsIntervalHours = 1;
const int desiredFileSize = 2000;
targetFolder.Properties.DesiredItemsPerFile = desiredFileSize;
IRepositoryWriter writer = targetFolder.GetWriter();
IDataRouter dataRouter = new NumberedDataRouter(subfolderCount);
writer.DataRouter = dataRouter;
writer.AllowSubfoldersCreation = true;
DateTime firstTime = DateTime.Now.AddDays(-10);
DateTime lastTime = DateTime.MinValue;
int itemsCount = 100000;
int n;
for (n = 0; n < itemsCount; ++n)
{
Mock.TestDataItem item = Mock.TestDataItem.GetTestItem(n);
lastTime = firstTime.AddHours(n * itemsIntervalHours);
item.DateTime = lastTime;
writer.Write(item);
}
writer.Flush();
writer.Close();
// will test lazy loading
targetFolder.UnloadSubfolders();
Assert.IsTrue(targetFolder.SubFolders.Count == subfolderCount, "Router had to make writer create the configured number of subfolders");
IRepositoryFolder firstItemSubfolder = targetFolder.GetDescendant(
dataRouter.GetRelativePath(Mock.TestDataItem.GetTestItem(0)), false);
Assert.AreEqual(firstTime, firstItemSubfolder.FirstTimestamp
, "Fisrt item timestamp reported incorrectly by Folder.FirstTimestamp");
Assert.AreEqual(firstTime, targetFolder.GetFirstItemTimestamp(true, false)
, "Fisrt item timestamp reported incorrectly by Folder.GetFirstItemTimestamp");
IRepositoryReader reader = targetFolder.GetReader(firstTime, true);
Assert.IsTrue(reader.HasData, "Folder just populated but no data can be read");
IDataItemRead ritem = null;
n = 0;
IRepositoryReader altReader = null;
SeekStatusListener seekStatusListener = new SeekStatusListener();
while (reader.HasData)
{
if (n > 0 && n % 100 == 0)
{
altReader = Repository.ObjectFactory.GetReader(reader.Position, seekStatusListener.HanldeStatus);
}
ritem = reader.Read();
Assert.IsNotNull(ritem, "reader.Read() returned null after returning true from HasData");
Assert.AreNotSame(targetFolder, ritem.RepositoryFolder, "Router failed");
Assert.IsInstanceOf <Mock.TestDataItem>(ritem.DataItem, "Data item read from repository is of different type");
Assert.AreEqual(firstTime.AddHours(n * itemsIntervalHours), ritem.DataItem.DateTime);
((Mock.TestDataItem)ritem.DataItem).Check(n);
if (altReader != null)
{
IDataItemRead altItem = altReader.Read();
Assert.AreEqual(ritem.DataItem.DateTime, altItem.DataItem.DateTime);
Assert.AreEqual(0, seekStatusListener.Statuses.Count);
}
++n;
}
Assert.AreEqual(lastTime, ritem.DataItem.DateTime, "Last item has unexpected timestamp");
Assert.AreEqual(itemsCount, n, "Unexpected number of data items read");
DateTime timestampToSeek = firstTime.AddHours(desiredFileSize / 3 * itemsIntervalHours);
reader.Seek(timestampToSeek);
Assert.IsTrue(reader.HasData, "Repeated Seek after reading all failed");
ritem = reader.Read();
Assert.IsNotNull(ritem);
Assert.AreEqual(timestampToSeek, ritem.DataItem.DateTime, "First read item timestamp unexpected");
reader.Direction = bfs.Repository.Util.EnumerationDirection.Backwards;
Assert.IsTrue(reader.HasData, "No data after reversing in the middle of data");
//ritem = reader.Read();
//Assert.AreEqual<DateTime>(timestampToSeek, ritem.DataItem.DateTime
// , "First read item timestamp unexpected after changing direction");
n = 0;
altReader = null;
while (reader.HasData)
{
if (n > 0 && n % 100 == 0)
{
if (altReader != null)
{
altReader.Dispose();
}
altReader = Repository.ObjectFactory.GetReader(reader.Position, seekStatusListener.HanldeStatus);
}
ritem = reader.Read();
Assert.IsNotNull(ritem, "reader.Read() returned null after returning true from HasData");
Assert.AreEqual(timestampToSeek.AddHours(-n * itemsIntervalHours), ritem.DataItem.DateTime);
if (altReader != null)
{
IDataItemRead altItem = altReader.Read();
Assert.AreEqual(ritem.DataItem.DateTime, altItem.DataItem.DateTime);
}
++n;
}
Assert.AreEqual(firstTime, ritem.DataItem.DateTime, "Did not pick up first item after reversing");
// reversing after reaching end
reader.Direction = bfs.Repository.Util.EnumerationDirection.Forwards;
ritem = reader.Read();
Assert.IsNotNull(ritem, "Did not read firts item reversing after reaching end");
Assert.AreEqual(firstTime, ritem.DataItem.DateTime, "Did not pick up first item after reversing after reaching end");
// cleanup
//targetFolder.Delete(true, false);
//Assert.IsFalse(Directory.Exists(targetFolderPath), "Test repo directory not removed from disk by Delete()");
}