public async Task SessionCreateDerivedPartitionCancellation()
{
var dataset = new Dataset();
var session = dataset.CreateSession();
// generate a test store
var originalStoreName = "OriginalStore";
GenerateTestStore(originalStoreName, StorePath);
// add a partition
var partition0 = session.AddPsiStorePartition(originalStoreName, StorePath, "Partition_0");
Assert.AreEqual(1, session.Partitions.Count);
Assert.AreEqual("Partition_0", session.Partitions[0].Name);
int multiplier = 7;
try
{
// create a cancellation token source that will automatically request cancellation after 500 ms
var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(500));
// create a derived partition which contains the values from the original stream multiplied by a multiplier
await session.CreateDerivedPsiPartitionAsync(
(pipeline, importer, exporter, parameter) =>
{
var inputStream = importer.OpenStream <int>("Root");
var derivedStream = inputStream.Sample(TimeSpan.FromMinutes(1), RelativeTimeInterval.Infinite).Select(x => x *parameter).Write("DerivedStream", exporter);
// add a dummy source and propose a long time interval so that the operation will block (and eventually be canceled)
var generator = Generators.Repeat(pipeline, 0, int.MaxValue, TimeSpan.FromMilliseconds(1000));
var replayTimeInterval = TimeInterval.LeftBounded(importer.MessageOriginatingTimeInterval.Left);
pipeline.ProposeReplayTime(replayTimeInterval);
},
multiplier,
"Partition_1",
false,
"DerivedStore",
StorePath,
null,
null,
cts.Token);
}
catch (OperationCanceledException)
{
// should NOT have created a new partition (but original partition should be intact)
Assert.AreEqual(1, session.Partitions.Count);
Assert.IsTrue(PsiStore.Exists("OriginalStore", StorePath));
Assert.IsFalse(PsiStore.Exists("DerivedStore", StorePath));
// verify original partition metadata
var originalPartition = session.Partitions[0] as Partition <PsiStoreStreamReader>;
Assert.AreEqual("Partition_0", originalPartition.Name);
Assert.AreEqual("OriginalStore", originalPartition.StoreName);
Assert.AreEqual($"{StorePath}{Path.DirectorySeparatorChar}OriginalStore.0000", originalPartition.StorePath);
throw;
}
}
public void SessionAddPartition()
{
var dataset = new Dataset();
var session = dataset.CreateSession();
Assert.AreEqual(0, session.Partitions.Count);
// generate a test store
GenerateTestStore("PsiStore", StorePath);
// add a partition
var partition0 = session.AddPsiStorePartition("PsiStore", StorePath, "Partition_0");
Assert.AreEqual(1, session.Partitions.Count);
Assert.AreEqual("Partition_0", session.Partitions[0].Name);
// verify new originating time intervals (session and dataset)
Assert.AreEqual(partition0.OriginatingTimeInterval.Left, session.OriginatingTimeInterval.Left);
Assert.AreEqual(partition0.OriginatingTimeInterval.Right, session.OriginatingTimeInterval.Right);
Assert.AreEqual(partition0.OriginatingTimeInterval.Left, dataset.OriginatingTimeInterval.Left);
Assert.AreEqual(partition0.OriginatingTimeInterval.Right, dataset.OriginatingTimeInterval.Right);
// generate a new store with a different originating time interval than the first
GenerateTestStore("NewStore", StorePath);
// add a second partition with a different name
var partition1 = session.AddPsiStorePartition("NewStore", StorePath, "Partition_1");
Assert.AreEqual(2, session.Partitions.Count);
Assert.AreEqual("Partition_0", session.Partitions[0].Name);
Assert.AreEqual("Partition_1", session.Partitions[1].Name);
// verify new originating time intervals (session and dataset)
Assert.AreEqual(partition0.OriginatingTimeInterval.Left, session.OriginatingTimeInterval.Left);
Assert.AreEqual(partition1.OriginatingTimeInterval.Right, session.OriginatingTimeInterval.Right);
Assert.AreEqual(partition0.OriginatingTimeInterval.Left, dataset.OriginatingTimeInterval.Left);
Assert.AreEqual(partition1.OriginatingTimeInterval.Right, dataset.OriginatingTimeInterval.Right);
}
public void DatasetUnsavedChanges()
{
var dataset = new Dataset("autosave");
dataset.CreateSession("test-session1");
Assert.IsTrue(dataset.HasUnsavedChanges);
dataset.SaveAs("unsave.pds");
Assert.IsTrue(!dataset.HasUnsavedChanges);
}
public void SessionAddPartitionDuplicateName()
{
var dataset = new Dataset();
var session = dataset.CreateSession();
Assert.AreEqual(0, session.Partitions.Count);
// generate a test store
GenerateTestStore("PsiStore", StorePath);
// add a partition
session.AddPsiStorePartition("PsiStore", StorePath, "Partition_0");
Assert.AreEqual(1, session.Partitions.Count);
Assert.AreEqual("Partition_0", session.Partitions[0].Name);
// generate a new store with a different originating time interval than the first
GenerateTestStore("NewStore", StorePath);
// add a second partition with a duplicate name
session.AddPsiStorePartition("NewStore", StorePath, "Partition_0"); // should throw
}
public void DatasetAutoSave()
{
var datasetPath = Path.Join(StorePath, "autosave.pds");
var dataset = new Dataset("autosave", datasetPath, autoSave: true);
dataset.Name = "autosave-saved";
GenerateTestStore("store1", StorePath);
var session1 = dataset.CreateSession("test-session1");
var session2 = dataset.AddSessionFromPsiStore("store1", StorePath);
session1.Name = "no-longer-test-session1";
// open the dataset file as a different dataset and validate information
var sameDataset = Dataset.Load(datasetPath);
Assert.AreEqual("autosave-saved", sameDataset.Name);
Assert.AreEqual(2, sameDataset.Sessions.Count);
Assert.AreEqual("no-longer-test-session1", sameDataset.Sessions[0].Name);
Assert.AreEqual(session2.Name, sameDataset.Sessions[1].Name);
// remove a session and verify changes are saved.
dataset.RemoveSession(session1);
sameDataset = Dataset.Load(datasetPath);
Assert.AreEqual(1, sameDataset.Sessions.Count);
Assert.AreEqual(session2.Name, sameDataset.Sessions[0].Name);
Assert.AreEqual(1, sameDataset.Sessions[0].Partitions.Count);
Assert.AreEqual(session2.OriginatingTimeInterval.Left, sameDataset.Sessions[0].OriginatingTimeInterval.Left);
Assert.AreEqual(session2.OriginatingTimeInterval.Right, sameDataset.Sessions[0].OriginatingTimeInterval.Right);
// now we edit the session and we want to make sure the changes stick!
GenerateTestStore("store3", StorePath);
session2.AddPsiStorePartition("store3", StorePath);
sameDataset = Dataset.Load(datasetPath);
Assert.AreEqual(session2.Name, sameDataset.Sessions[0].Name);
Assert.AreEqual(2, sameDataset.Sessions[0].Partitions.Count);
Assert.AreEqual("store3", sameDataset.Sessions[0].Partitions[1].Name);
}
public async Task SessionCreateDerivedPartition()
{
var dataset = new Dataset();
var session = dataset.CreateSession();
// generate a test store
var originalStoreName = "OriginalStore";
GenerateTestStore(originalStoreName, StorePath);
// add a partition
var partition0 = session.AddPsiStorePartition(originalStoreName, StorePath, "Partition_0");
Assert.AreEqual(1, session.Partitions.Count);
Assert.AreEqual("Partition_0", session.Partitions[0].Name);
int multiplier = 7;
// create a derived partition which contains the values from the original stream multiplied by a multiplier
await session.CreateDerivedPsiPartitionAsync(
(pipeline, importer, exporter, parameter) =>
{
var inputStream = importer.OpenStream <int>("Root");
var derivedStream = inputStream.Select(x => x *parameter).Write("DerivedStream", exporter);
},
multiplier,
"Partition_1",
false,
"DerivedStore",
StorePath);
// should have created a new store partition
Assert.AreEqual(2, session.Partitions.Count);
Assert.IsTrue(PsiStore.Exists("OriginalStore", StorePath));
Assert.IsTrue(PsiStore.Exists("DerivedStore", StorePath));
// verify partition metadata
var originalPartition = session.Partitions[0] as Partition <PsiStoreStreamReader>;
Assert.AreEqual("Partition_0", originalPartition.Name);
Assert.AreEqual("OriginalStore", originalPartition.StoreName);
Assert.AreEqual($"{StorePath}{Path.DirectorySeparatorChar}OriginalStore.0000", originalPartition.StorePath);
var derivedPartition = session.Partitions[1] as Partition <PsiStoreStreamReader>;
Assert.AreEqual("Partition_1", derivedPartition.Name);
Assert.AreEqual("DerivedStore", derivedPartition.StoreName);
Assert.AreEqual(StorePath, derivedPartition.StorePath);
// collections to capture stream values
var originalValues = new List <int>();
var originalTimes = new List <DateTime>();
var derivedValues = new List <int>();
var derivedTimes = new List <DateTime>();
// read stream values from the partitions
using (var pipeline = Pipeline.Create())
{
var originalPartitionImporter = PsiStore.Open(pipeline, originalPartition.StoreName, originalPartition.StorePath);
originalPartitionImporter.OpenStream <int>("Root").Do(
(i, e) =>
{
originalValues.Add(i);
originalTimes.Add(e.OriginatingTime);
});
var derivedPartitionImporter = PsiStore.Open(pipeline, derivedPartition.StoreName, derivedPartition.StorePath);
derivedPartitionImporter.OpenStream <int>("DerivedStream").Do(
(i, e) =>
{
derivedValues.Add(i);
derivedTimes.Add(e.OriginatingTime);
});
pipeline.Run();
}
// verify that we read the data
Assert.AreEqual(10, originalValues.Count);
Assert.AreEqual(10, originalTimes.Count);
Assert.AreEqual(10, derivedValues.Count);
Assert.AreEqual(10, derivedTimes.Count);
// verify values from both streams are what we expect
CollectionAssert.AreEqual(originalValues.Select(x => x * multiplier).ToList(), derivedValues);
CollectionAssert.AreEqual(originalTimes, derivedTimes);
}
