public UnicornDataProvider(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IFieldFilter fieldFilter, IUnicornDataProviderLogger logger, IUnicornDataProviderConfiguration configuration)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(fieldFilter, "fieldPredicate");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(configuration, "configuration");
_logger = logger;
_disableTransparentSync = !configuration.EnableTransparentSync;
_predicate = predicate;
_fieldFilter = fieldFilter;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
try
{
_targetDataStore.RegisterForChanges(RemoveItemFromCaches);
}
catch (NotImplementedException)
{
// if the data store doesn't implement watching, cool story bruv
}
}
public UnicornDataProvider(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IFieldFilter fieldFilter, IUnicornDataProviderLogger logger, IUnicornDataProviderConfiguration dataProviderConfiguration, PredicateRootPathResolver rootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(fieldFilter, "fieldPredicate");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(dataProviderConfiguration, "configuration");
Assert.ArgumentNotNull(rootPathResolver, "rootPathResolver");
_logger = logger;
_dataProviderConfiguration = dataProviderConfiguration;
_rootPathResolver = rootPathResolver;
_predicate = predicate;
_fieldFilter = fieldFilter;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
// enable capturing recycle bin and archive restores to serialize the target item if included
EventManager.Subscribe <RestoreItemCompletedEvent>(HandleItemRestored);
try
{
_targetDataStore.RegisterForChanges(RemoveItemFromCaches);
}
catch (NotImplementedException)
{
// if the data store doesn't implement watching, cool story bruv
}
}
public UnicornDataProvider(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IFieldFilter fieldFilter, IUnicornDataProviderLogger logger, IUnicornDataProviderConfiguration configuration)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(fieldFilter, "fieldPredicate");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(configuration, "configuration");
_logger = logger;
_configuration = configuration;
_predicate = predicate;
_fieldFilter = fieldFilter;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
try
{
_targetDataStore.RegisterForChanges(RemoveItemFromCaches);
}
catch (NotImplementedException)
{
// if the data store doesn't implement watching, cool story bruv
}
}
public UnicornDataProvider(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IFieldFilter fieldFilter, IUnicornDataProviderLogger logger, IUnicornDataProviderConfiguration dataProviderConfiguration, ISyncConfiguration syncConfiguration, PredicateRootPathResolver rootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, nameof(targetDataStore));
Assert.ArgumentNotNull(predicate, nameof(predicate));
Assert.ArgumentNotNull(fieldFilter, nameof(fieldFilter));
Assert.ArgumentNotNull(logger, nameof(logger));
Assert.ArgumentNotNull(sourceDataStore, nameof(sourceDataStore));
Assert.ArgumentNotNull(dataProviderConfiguration, nameof(dataProviderConfiguration));
Assert.ArgumentNotNull(rootPathResolver, nameof(rootPathResolver));
Assert.ArgumentNotNull(syncConfiguration, nameof(syncConfiguration));
_logger = logger;
_dataProviderConfiguration = dataProviderConfiguration;
_syncConfiguration = syncConfiguration;
_rootPathResolver = rootPathResolver;
_predicate = predicate;
_fieldFilter = fieldFilter;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
// enable capturing recycle bin and archive restores to serialize the target item if included
EventManager.Subscribe<RestoreItemCompletedEvent>(HandleItemRestored);
try
{
_targetDataStore.RegisterForChanges(RemoveItemFromCaches);
}
catch (NotImplementedException)
{
// if the data store doesn't implement watching, cool story bruv
}
}
public PredicateRootPathResolver(IPredicate predicate, ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, ILogger logger)
{
_predicate = predicate;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
_logger = logger;
}
/// <summary>
/// Recycles a whole tree of items and reports their progress
/// </summary>
/// <param name="items">The item(s) to delete. Note that their children will be deleted before them, and also be reported upon.</param>
/// <param name="sourceStore"></param>
/// <param name="deleteMessage">The status message to write for each deleted item</param>
public static void RecycleItems(IEnumerable<IItemData> items, ISourceDataStore sourceStore, Action<IItemData> deleteMessage)
{
Assert.ArgumentNotNull(items, "items");
foreach (var item in items)
RecycleItem(item, sourceStore, deleteMessage);
}
// TODO
private UnicornDataProvider CreateTestProvider(Database db, ITargetDataStore targetDataStore = null, ISourceDataStore sourceDataStore = null, IPredicate predicate = null, IFieldFilter filter = null, IUnicornDataProviderLogger logger = null, bool enableTransparentSync = false)
{
if (predicate == null)
{
predicate = CreateInclusiveTestPredicate();
}
if (filter == null)
{
filter = Substitute.For<IFieldFilter>();
filter.Includes(Arg.Any<Guid>()).Returns(true);
}
targetDataStore = targetDataStore ?? Substitute.For<ITargetDataStore>();
sourceDataStore = sourceDataStore ?? Substitute.For<ISourceDataStore>();
var dp = new UnicornDataProvider(targetDataStore,
sourceDataStore,
predicate,
filter,
logger ?? Substitute.For<IUnicornDataProviderLogger>(),
new DefaultUnicornDataProviderConfiguration(enableTransparentSync),
new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, Substitute.For<ILogger>()));
dp.ParentDataProvider = db.GetDataProviders().First();
return dp;
}
public PredicateRootPathResolver(IPredicate predicate, ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, ILogger logger)
{
_predicate = predicate;
_targetDataStore = targetDataStore;
_sourceDataStore = sourceDataStore;
_logger = logger;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
}
//[Fact]
//public void LoadTree_IdentifiesOrphanChildItem()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.Is<ISourceItem[]>(y => y.Contains(root.Children[0]))));
//}
//[Fact]
//public void LoadTree_DoesNotIdentifyValidChildrenAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedChildItem.SetupGet(y => y.DatabaseName).Returns("childflag");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// sourceDataProvider.Setup(x => x.GetItemById("childflag", It.IsAny<ID>())).Returns(root.Children[0]);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_DoesNotIdentifySkippedItemsAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// var predicate = CreateExclusiveTestPredicate(new[] { serializedRootItem }, new[] { root });
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById(It.IsAny<string>(), It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_UpdatesWhenItemDoesNotExistInSource()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateNewSerializedItem(serializedChildItem));
//}
//[Fact]
//public void LoadTree_AbortsWhenConsistencyCheckFails()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Test");
// serializedRootItem.Setup(x => x.Deserialize(false)).Returns(root);
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(It.IsAny<ISourceItem>())).Returns(serializedRootItem);
// var logger = Substitute.For<ISerializationLoaderLogger>();
// var consistencyChecker = Substitute.For<IConsistencyChecker>();
// consistencyChecker.Setup(x => x.IsConsistent(It.IsAny<IItemData>())).Returns(false);
// var loader = CreateTestLoader(null, serializationProvider, predicate, null, logger);
// Assert.Throws<ConsistencyException>((() => loader.LoadTree(serializedRootItem, Substitute.For<IDeserializeFailureRetryer>(), consistencyChecker)));
//}
private SerializationLoader CreateTestLoader(ISourceDataStore sourceDataStore = null, ITargetDataStore targetDataStore = null, IPredicate predicate = null, IEvaluator evaluator = null, ISerializationLoaderLogger logger = null)
{
if (targetDataStore == null)
{
targetDataStore = Substitute.For <ITargetDataStore>();
}
if (sourceDataStore == null)
{
sourceDataStore = Substitute.For <ISourceDataStore>();
}
if (predicate == null)
{
predicate = CreateInclusiveTestPredicate();
}
if (evaluator == null)
{
evaluator = Substitute.For <IEvaluator>();
}
if (logger == null)
{
logger = Substitute.For <ISerializationLoaderLogger>();
}
var mockLogger2 = Substitute.For <ILogger>();
var pathResolver = new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, mockLogger2);
return(new SerializationLoader(sourceDataStore, targetDataStore, predicate, evaluator, logger, pathResolver));
}
public NewItemOnlyEvaluator(INewItemOnlyEvaluatorLogger logger, ISourceDataStore sourceDataStore)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
_logger = logger;
_sourceDataStore = sourceDataStore;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator, ConfigurationDependencyResolver dependencyResolver)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
_dependencyResolver = dependencyResolver;
}
public ConfigurationDetails(IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, IEvaluator evaluator, ConfigurationDependencyResolver dependencyResolver)
{
_predicate = predicate;
_serializationStore = serializationStore;
_sourceDataStore = sourceDataStore;
_evaluator = evaluator;
_dependencyResolver = dependencyResolver;
}
/// <summary>
/// Recycles a whole tree of items and reports their progress
/// </summary>
/// <param name="items">The item(s) to delete. Note that their children will be deleted before them, and also be reported upon.</param>
/// <param name="sourceStore"></param>
/// <param name="deleteMessage">The status message to write for each deleted item</param>
public static void RecycleItems(IEnumerable <IItemData> items, ISourceDataStore sourceStore, Action <IItemData> deleteMessage)
{
Assert.ArgumentNotNull(items, "items");
foreach (var item in items)
{
RecycleItem(item, sourceStore, deleteMessage);
}
}
/// <summary>
/// Deletes an item from the source data provider
/// </summary>
private static void RecycleItem(IItemData itemData, ISourceDataStore sourceStore, Action <IItemData> deleteMessage)
{
var children = sourceStore.GetChildren(itemData);
RecycleItems(children, sourceStore, deleteMessage);
deleteMessage(itemData);
sourceStore.Remove(itemData);
}
/// <summary>
/// Deletes an item from the source data provider
/// </summary>
private static void RecycleItem(IItemData itemData, ISourceDataStore sourceStore, Action<IItemData> deleteMessage)
{
var children = sourceStore.GetChildren(itemData);
RecycleItems(children, sourceStore, deleteMessage);
deleteMessage(itemData);
sourceStore.Remove(itemData);
}
public NewItemOnlyEvaluator(INewItemOnlyEvaluatorLogger logger, ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(targetDataStore, "targetDataStore");
_logger = logger;
_sourceDataStore = sourceDataStore;
_targetDataStore = targetDataStore;
}
public SerializedAsMasterEvaluator(ISerializedAsMasterEvaluatorLogger logger, IItemComparer itemComparer, IFieldFilter fieldFilter, ISourceDataStore sourceDataStore)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(itemComparer, "itemComparer");
Assert.ArgumentNotNull(fieldFilter, "fieldFilter");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
_logger = logger;
_itemComparer = itemComparer;
_fieldFilter = fieldFilter;
_sourceDataStore = sourceDataStore;
}
public NewItemOnlyEvaluator(INewItemOnlyEvaluatorLogger logger, ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IConfiguration parentConfiguration)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(targetDataStore, "targetDataStore");
Assert.ArgumentNotNull(parentConfiguration, "parentConfiguration");
_logger = logger;
_sourceDataStore = sourceDataStore;
_targetDataStore = targetDataStore;
_parentConfiguration = parentConfiguration;
}
public SerializedAsMasterEvaluator(ISerializedAsMasterEvaluatorLogger logger, IItemComparer itemComparer, IFieldFilter fieldFilter, ISourceDataStore sourceDataStore)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(itemComparer, "itemComparer");
Assert.ArgumentNotNull(fieldFilter, "fieldFilter");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
_logger = logger;
_itemComparer = itemComparer;
_fieldFilter = fieldFilter;
_sourceDataStore = sourceDataStore;
}
public NewItemOnlyEvaluator(INewItemOnlyEvaluatorLogger logger, ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IConfiguration parentConfiguration)
{
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(targetDataStore, "targetDataStore");
Assert.ArgumentNotNull(parentConfiguration, "parentConfiguration");
_logger = logger;
_sourceDataStore = sourceDataStore;
_targetDataStore = targetDataStore;
_parentConfiguration = parentConfiguration;
}
public SerializedAsMasterEvaluator(ILogger globalLogger, ISerializedAsMasterEvaluatorLogger logger, IItemComparer itemComparer, IFieldFilter fieldFilter, ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore) : base(logger, sourceDataStore, targetDataStore)
{
Assert.ArgumentNotNull(globalLogger, "globalLogger");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(itemComparer, "itemComparer");
Assert.ArgumentNotNull(fieldFilter, "fieldFilter");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
_globalLogger = globalLogger;
_logger = logger;
_itemComparer = itemComparer;
_fieldFilter = fieldFilter;
_sourceDataStore = sourceDataStore;
}
public SerializedAsMasterEvaluator(ILogger globalLogger, ISerializedAsMasterEvaluatorLogger logger, IItemComparer itemComparer, IFieldFilter fieldFilter, ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IConfiguration parentConfiguration) : base(logger, sourceDataStore, targetDataStore, parentConfiguration)
{
Assert.ArgumentNotNull(globalLogger, "globalLogger");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(itemComparer, "itemComparer");
Assert.ArgumentNotNull(fieldFilter, "fieldFilter");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
_globalLogger = globalLogger;
_logger = logger;
_itemComparer = itemComparer;
_fieldFilter = fieldFilter;
_sourceDataStore = sourceDataStore;
_parentConfiguration = parentConfiguration;
}
//[Fact]
//public void LoadTree_IdentifiesOrphanChildItem()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.Is<ISourceItem[]>(y => y.Contains(root.Children[0]))));
//}
//[Fact]
//public void LoadTree_DoesNotIdentifyValidChildrenAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedChildItem.SetupGet(y => y.DatabaseName).Returns("childflag");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// sourceDataProvider.Setup(x => x.GetItemById("childflag", It.IsAny<ID>())).Returns(root.Children[0]);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_DoesNotIdentifySkippedItemsAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// var predicate = CreateExclusiveTestPredicate(new[] { serializedRootItem }, new[] { root });
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById(It.IsAny<string>(), It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_UpdatesWhenItemDoesNotExistInSource()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateNewSerializedItem(serializedChildItem));
//}
//[Fact]
//public void LoadTree_AbortsWhenConsistencyCheckFails()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Test");
// serializedRootItem.Setup(x => x.Deserialize(false)).Returns(root);
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(It.IsAny<ISourceItem>())).Returns(serializedRootItem);
// var logger = Substitute.For<ISerializationLoaderLogger>();
// var consistencyChecker = Substitute.For<IConsistencyChecker>();
// consistencyChecker.Setup(x => x.IsConsistent(It.IsAny<IItemData>())).Returns(false);
// var loader = CreateTestLoader(null, serializationProvider, predicate, null, logger);
// Assert.Throws<ConsistencyException>((() => loader.LoadTree(serializedRootItem, Substitute.For<IDeserializeFailureRetryer>(), consistencyChecker)));
//}
private SerializationLoader CreateTestLoader(ISourceDataStore sourceDataStore = null, ITargetDataStore targetDataStore = null, IPredicate predicate = null, IEvaluator evaluator = null, ISyncConfiguration syncConfiguration = null, ISerializationLoaderLogger logger = null)
{
targetDataStore = targetDataStore ?? Substitute.For <ITargetDataStore>();
sourceDataStore = sourceDataStore ?? Substitute.For <ISourceDataStore>();
predicate = predicate ?? CreateInclusiveTestPredicate();
evaluator = evaluator ?? Substitute.For <IEvaluator>();
logger = logger ?? Substitute.For <ISerializationLoaderLogger>();
syncConfiguration = syncConfiguration ?? new TestSyncConfiguration();
var mockLogger2 = Substitute.For <ILogger>();
var pathResolver = new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, mockLogger2);
return(new SerializationLoader(sourceDataStore, targetDataStore, predicate, evaluator, logger, syncConfiguration, Substitute.For <IUnicornDataProviderConfiguration>(), pathResolver));
}
public SerializationLoader(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(evaluator, "evaluator");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(predicateRootPathResolver, "predicateRootPathResolver");
Logger = logger;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
public SerializationLoader(ITargetDataStore targetDataStore, ISourceDataStore sourceDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, "serializationProvider");
Assert.ArgumentNotNull(sourceDataStore, "sourceDataStore");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(evaluator, "evaluator");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(predicateRootPathResolver, "predicateRootPathResolver");
Logger = logger;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
public SerializationLoader(ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, ISyncConfiguration syncConfiguration, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, nameof(targetDataStore));
Assert.ArgumentNotNull(sourceDataStore, nameof(sourceDataStore));
Assert.ArgumentNotNull(predicate, nameof(predicate));
Assert.ArgumentNotNull(evaluator, nameof(evaluator));
Assert.ArgumentNotNull(logger, nameof(logger));
Assert.ArgumentNotNull(predicateRootPathResolver, nameof(predicateRootPathResolver));
Assert.ArgumentNotNull(syncConfiguration, nameof(syncConfiguration));
Logger = logger;
SyncConfiguration = syncConfiguration;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
public SerializationLoader(ISourceDataStore sourceDataStore, ITargetDataStore targetDataStore, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, ISyncConfiguration syncConfiguration, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(targetDataStore, nameof(targetDataStore));
Assert.ArgumentNotNull(sourceDataStore, nameof(sourceDataStore));
Assert.ArgumentNotNull(predicate, nameof(predicate));
Assert.ArgumentNotNull(evaluator, nameof(evaluator));
Assert.ArgumentNotNull(logger, nameof(logger));
Assert.ArgumentNotNull(predicateRootPathResolver, nameof(predicateRootPathResolver));
Assert.ArgumentNotNull(syncConfiguration, nameof(syncConfiguration));
Logger = logger;
SyncConfiguration = syncConfiguration;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
TargetDataStore = targetDataStore;
SourceDataStore = sourceDataStore;
}
protected virtual void DumpTreeInternal(IItemData root, IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, ILogger logger)
{
CacheManager.ClearAllCaches(); // BOOM! This clears all caches before we begin;
// because for a TpSync configuration we could have TpSync items in the data cache which 'taint' the reserialize
// from being purely database
// we throw items into this queue, and let a thread pool pick up anything available to process in parallel. only the children of queued items are processed, not the item itself
ConcurrentQueue <IItemData> processQueue = new ConcurrentQueue <IItemData>();
// exceptions thrown on background threads are left in here
ConcurrentQueue <Exception> errors = new ConcurrentQueue <Exception>();
// we keep track of how many threads are actively processing something so we know when to end the threads
// (e.g. a thread could have nothing in the queue right now, but that's because a different thread is about
// to add 8 things to the queue - so it shouldn't quit till all is done)
int activeThreads = 0;
using (new UnicornOperationContext())
{
var rootResult = DumpItemInternal(root, predicate, serializationStore);
if (!rootResult.IsIncluded)
{
return;
}
}
processQueue.Enqueue(root);
Thread[] pool = Enumerable.Range(0, ThreadCount).Select(i => new Thread(() =>
{
Process:
Interlocked.Increment(ref activeThreads);
IItemData parentItem;
while (processQueue.TryDequeue(out parentItem) && errors.Count == 0)
{
using (new UnicornOperationContext()) // disablers only work on the current thread. So we need to disable on all worker threads
{
var children = sourceDataStore.GetChildren(parentItem);
foreach (var item in children)
{
try
{
// we dump each item in the queue item
// we do a whole array of children at a time because this makes the serialization of all children of a given item single threaded
// this gives us a deterministic result of naming when name collisions occur, which means trees will not contain random differences
// when reserialized (oh joy, that)
var dump = DumpItemInternal(item, predicate, serializationStore);
if (dump.IsIncluded)
{
// if the item is included, then we add its children as a queued work item
processQueue.Enqueue(item);
}
else
{
logger.Warn("[S] {0} because {1}".FormatWith(item.GetDisplayIdentifier(), dump.Justification));
}
}
catch (Exception ex)
{
errors.Enqueue(ex);
break;
}
}
}
}
// if we get here, the queue was empty. let's make ourselves inactive.
Interlocked.Decrement(ref activeThreads);
// if some other thread in our pool was doing stuff, sleep for a sec to see if we can pick up their work
if (activeThreads > 0)
{
Thread.Sleep(10);
goto Process; // OH MY GOD :)
}
})).ToArray();
// start the thread pool
foreach (var thread in pool)
{
thread.Start();
}
// ...and then wait for all the threads to finish
foreach (var thread in pool)
{
thread.Join();
}
CacheManager.ClearAllCaches(); // BOOM! And we clear everything again at the end, because now
// for a TpSync configuration we might have DATABASE items in cache where we want TpSync.
if (errors.Count > 0)
{
throw new AggregateException(errors);
}
}
public RainbowRenderingReader(ISourceDataStore dataStore) : base(dataStore)
{
// Controller Rendering
ReaderTemplateId.Add(new Guid("{2A3E91A0-7987-44B5-AB34-35C2D9DE83B9}"));
}
public void RetryAll(ISourceDataStore sourceDataProvider, Action <IItemData> retrySingleItemAction, Action <IItemData> retryTreeAction)
{
Assert.ArgumentNotNull(sourceDataProvider, "sourceDataProvider");
Assert.ArgumentNotNull(retrySingleItemAction, "retrySingleItemAction");
Assert.ArgumentNotNull(retryTreeAction, "retryTreeAction");
if (_itemFailures.Count > 0)
{
List <Failure> originalItemFailures;
List <Failure> originalTreeFailures;
do
{
sourceDataProvider.ResetTemplateEngine();
// save existing failures collection
originalItemFailures = new List <Failure>(_itemFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_itemFailures.Clear();
foreach (var failure in originalItemFailures)
{
// retry loading a single item failure
var item = failure.Reference;
if (item != null)
{
try
{
retrySingleItemAction(item);
}
catch (Exception reason)
{
_itemFailures.Add(new Failure(failure.Reference, reason));
}
continue;
}
// retry loading a reference failure (note the continues in the above ensure execution never arrives here for items)
retryTreeAction(failure.Reference);
}
}while (_itemFailures.Count > 0 && _itemFailures.Count < originalItemFailures.Count); // continue retrying until all possible failures have been fixed
do
{
sourceDataProvider.ResetTemplateEngine();
// save existing failures collection
originalTreeFailures = new List <Failure>(_treeFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_treeFailures.Clear();
foreach (var failure in originalTreeFailures)
{
// retry loading a tree failure
retryTreeAction(failure.Reference);
}
}while (_treeFailures.Count > 0 && _treeFailures.Count < originalTreeFailures.Count); // continue retrying until all possible failures have been fixed
}
if (_itemFailures.Count > 0 || _treeFailures.Count > 0)
{
var exceptions = new List <DeserializationException>();
foreach (var failure in _itemFailures)
{
exceptions.Add(new DeserializationException(failure.Reference.GetDisplayIdentifier(), failure.Reference, failure.Reason));
}
foreach (var failure in _treeFailures)
{
exceptions.Add(new DeserializationException(string.Format("This tree failed to load: {0} (the error may not be on this item, see the details below)", failure.Reference.GetDisplayIdentifier()), failure.Reference, failure.Reason));
}
throw new DeserializationAggregateException("Some directories could not be loaded.")
{
InnerExceptions = exceptions.ToArray()
};
}
}
public RainbowSettingsReader(ISourceDataStore dataStore, string settingsRootPath,
IConfigurationProvider configurationProvider) : base(dataStore)
{
_configurationProvider = configurationProvider;
ReaderStartPath = settingsRootPath;
}
public RainbowTemplateReader(ISourceDataStore dataStore, IHelixModuleProvider helixModuleProvider) :
base(dataStore)
{
_helixModuleProvider = helixModuleProvider;
ReaderTemplateId.Add(TemplateGuids.Template);
}
protected virtual void DumpTreeInternal(IItemData root, IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, ILogger logger)
{
// we throw items into this queue, and let a thread pool pick up anything available to process in parallel. only the children of queued items are processed, not the item itself
ConcurrentQueue<IItemData> processQueue = new ConcurrentQueue<IItemData>();
// exceptions thrown on background threads are left in here
ConcurrentQueue<Exception> errors = new ConcurrentQueue<Exception>();
// we keep track of how many threads are actively processing something so we know when to end the threads
// (e.g. a thread could have nothing in the queue right now, but that's because a different thread is about
// to add 8 things to the queue - so it shouldn't quit till all is done)
int activeThreads = 0;
var rootResult = DumpItemInternal(root, predicate, serializationStore);
if (!rootResult.IsIncluded) return;
processQueue.Enqueue(root);
Thread[] pool = Enumerable.Range(0, ThreadCount).Select(i => new Thread(() =>
{
Process:
Interlocked.Increment(ref activeThreads);
IItemData parentItem;
while (processQueue.TryDequeue(out parentItem) && errors.Count == 0)
{
using (new SecurityDisabler())
{
var children = sourceDataStore.GetChildren(parentItem);
foreach (var item in children)
{
try
{
// we dump each item in the queue item
// we do a whole array of children at a time because this makes the serialization of all children of a given item single threaded
// this gives us a deterministic result of naming when name collisions occur, which means trees will not contain random differences
// when reserialized (oh joy, that)
var dump = DumpItemInternal(item, predicate, serializationStore);
if (dump.IsIncluded)
{
// if the item is included, then we add its children as a queued work item
processQueue.Enqueue(item);
}
else
{
logger.Warn("[S] {0} because {1}".FormatWith(item.GetDisplayIdentifier(), dump.Justification));
}
}
catch (Exception ex)
{
errors.Enqueue(ex);
break;
}
}
}
}
// if we get here, the queue was empty. let's make ourselves inactive.
Interlocked.Decrement(ref activeThreads);
// if some other thread in our pool was doing stuff, sleep for a sec to see if we can pick up their work
if (activeThreads > 0)
{
Thread.Sleep(10);
goto Process; // OH MY GOD :)
}
})).ToArray();
// start the thread pool
foreach (var thread in pool) thread.Start();
// ...and then wait for all the threads to finish
foreach (var thread in pool) thread.Join();
if (errors.Count > 0) throw new AggregateException(errors);
}
// TODO
private UnicornDataProvider CreateTestProvider(Database db, ITargetDataStore targetDataStore = null, ISourceDataStore sourceDataStore = null, IPredicate predicate = null, IFieldFilter filter = null, IUnicornDataProviderLogger logger = null, ISyncConfiguration syncConfiguration = null, bool enableTransparentSync = false)
{
if (predicate == null)
{
predicate = CreateInclusiveTestPredicate();
}
if (filter == null)
{
filter = Substitute.For <IFieldFilter>();
filter.Includes(Arg.Any <Guid>()).Returns(true);
}
targetDataStore = targetDataStore ?? Substitute.For <ITargetDataStore>();
sourceDataStore = sourceDataStore ?? Substitute.For <ISourceDataStore>();
syncConfiguration = syncConfiguration ?? Substitute.For <ISyncConfiguration>();
var dp = new UnicornDataProvider(targetDataStore,
sourceDataStore,
predicate,
filter,
logger ?? Substitute.For <IUnicornDataProviderLogger>(),
new DefaultUnicornDataProviderConfiguration(enableTransparentSync),
syncConfiguration,
new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, Substitute.For <ILogger>()));
dp.ParentDataProvider = db.GetDataProviders().First();
return(dp);
}
public void RetryAll(ISourceDataStore sourceDataProvider, Action<IItemData> retrySingleItemAction, Action<IItemData> retryTreeAction)
{
Assert.ArgumentNotNull(sourceDataProvider, "sourceDataProvider");
Assert.ArgumentNotNull(retrySingleItemAction, "retrySingleItemAction");
Assert.ArgumentNotNull(retryTreeAction, "retryTreeAction");
if (_itemFailures.Count > 0)
{
List<Failure> originalItemFailures;
List<Failure> originalTreeFailures;
do
{
sourceDataProvider.ResetTemplateEngine();
// save existing failures collection
originalItemFailures = new List<Failure>(_itemFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_itemFailures.Clear();
foreach (var failure in originalItemFailures)
{
// retry loading a single item failure
var item = failure.Reference;
if (item != null)
{
try
{
retrySingleItemAction(item);
}
catch (Exception reason)
{
_itemFailures.Add(new Failure(failure.Reference, reason));
}
continue;
}
// retry loading a reference failure (note the continues in the above ensure execution never arrives here for items)
retryTreeAction(failure.Reference);
}
}
while (_itemFailures.Count > 0 && _itemFailures.Count < originalItemFailures.Count); // continue retrying until all possible failures have been fixed
do
{
sourceDataProvider.ResetTemplateEngine();
// save existing failures collection
originalTreeFailures = new List<Failure>(_treeFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_treeFailures.Clear();
foreach (var failure in originalTreeFailures)
{
// retry loading a tree failure
retryTreeAction(failure.Reference);
}
}
while (_treeFailures.Count > 0 && _treeFailures.Count < originalTreeFailures.Count); // continue retrying until all possible failures have been fixed
}
if (_itemFailures.Count > 0 || _treeFailures.Count > 0)
{
var exceptions = new List<DeserializationException>();
foreach (var failure in _itemFailures)
{
exceptions.Add(new DeserializationException(failure.Reference.GetDisplayIdentifier(), failure.Reference, failure.Reason));
}
foreach (var failure in _treeFailures)
{
exceptions.Add(new DeserializationException(string.Format("This tree failed to load: {0} (the error may not be on this item, see the details below)", failure.Reference.GetDisplayIdentifier()), failure.Reference, failure.Reason));
}
throw new DeserializationAggregateException("Some directories could not be loaded.") { InnerExceptions = exceptions.ToArray() };
}
}
protected virtual void DumpTreeInternal(IItemData root, IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, ILogger logger, IUnicornDataProviderConfiguration dpConfig)
{
if (dpConfig.EnableTransparentSync)
{
CacheManager.ClearAllCaches();
// BOOM! This clears all caches before we begin;
// because for a TpSync configuration we could have TpSync items in the data cache which 'taint' the reserialize
// from being purely database
}
// we throw items into this queue, and let a thread pool pick up anything available to process in parallel. only the children of queued items are processed, not the item itself
var processQueue = new Queue <IItemData>();
using (new UnicornOperationContext())
{
var rootResult = DumpItemInternal(root, predicate, serializationStore);
if (!rootResult.IsIncluded)
{
return;
}
}
processQueue.Enqueue(root);
IItemData parentItem;
while (processQueue.Count > 0)
{
parentItem = processQueue.Dequeue();
using (new UnicornOperationContext()) // disablers only work on the current thread. So we need to disable on all worker threads
{
var children = sourceDataStore.GetChildren(parentItem);
foreach (var item in children)
{
// we dump each item in the queue item
// we do a whole array of children at a time because this makes the serialization of all children of a given item single threaded
// this gives us a deterministic result of naming when name collisions occur, which means trees will not contain random differences
// when reserialized (oh joy, that)
var dump = DumpItemInternal(item, predicate, serializationStore);
if (dump.IsIncluded)
{
// if the item is included, then we add its children as a queued work item
processQueue.Enqueue(item);
}
else
{
logger.Warn("[S] {0} because {1}".FormatWith(item.GetDisplayIdentifier(), dump.Justification));
}
}
}
}
if (dpConfig.EnableTransparentSync)
{
CacheManager.ClearAllCaches();
// BOOM! And we clear everything again at the end, because now
// for a TpSync configuration we might have DATABASE items in cache where we want TpSync.
}
}
//[Fact]
//public void LoadTree_IdentifiesOrphanChildItem()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.Is<ISourceItem[]>(y => y.Contains(root.Children[0]))));
//}
//[Fact]
//public void LoadTree_DoesNotIdentifyValidChildrenAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedChildItem.SetupGet(y => y.DatabaseName).Returns("childflag");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// sourceDataProvider.Setup(x => x.GetItemById("childflag", It.IsAny<ID>())).Returns(root.Children[0]);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_DoesNotIdentifySkippedItemsAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// var predicate = CreateExclusiveTestPredicate(new[] { serializedRootItem }, new[] { root });
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById(It.IsAny<string>(), It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_UpdatesWhenItemDoesNotExistInSource()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateNewSerializedItem(serializedChildItem));
//}
//[Fact]
//public void LoadTree_AbortsWhenConsistencyCheckFails()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Test");
// serializedRootItem.Setup(x => x.Deserialize(false)).Returns(root);
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(It.IsAny<ISourceItem>())).Returns(serializedRootItem);
// var logger = Substitute.For<ISerializationLoaderLogger>();
// var consistencyChecker = Substitute.For<IConsistencyChecker>();
// consistencyChecker.Setup(x => x.IsConsistent(It.IsAny<IItemData>())).Returns(false);
// var loader = CreateTestLoader(null, serializationProvider, predicate, null, logger);
// Assert.Throws<ConsistencyException>((() => loader.LoadTree(serializedRootItem, Substitute.For<IDeserializeFailureRetryer>(), consistencyChecker)));
//}
private SerializationLoader CreateTestLoader(ISourceDataStore sourceDataStore = null, ITargetDataStore targetDataStore = null, IPredicate predicate = null, IEvaluator evaluator = null, ISerializationLoaderLogger logger = null)
{
if (targetDataStore == null) targetDataStore = Substitute.For<ITargetDataStore>();
if (sourceDataStore == null) sourceDataStore = Substitute.For<ISourceDataStore>();
if (predicate == null) predicate = CreateInclusiveTestPredicate();
if (evaluator == null) evaluator = Substitute.For<IEvaluator>();
if (logger == null) logger = Substitute.For<ISerializationLoaderLogger>();
var mockLogger2 = Substitute.For<ILogger>();
var pathResolver = new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, mockLogger2);
return new SerializationLoader(sourceDataStore, targetDataStore, predicate, evaluator, logger, pathResolver);
}
protected RainbowReader(ISourceDataStore dataStore)
{
DataStore = dataStore;
ReaderTemplateId = new HashSet <Guid>();
}
public virtual void RetryAll(ISourceDataStore sourceDataStore, Action <IItemData> retrySingleItemAction, Action <IItemData> retryTreeAction)
{
Assert.ArgumentNotNull(sourceDataStore, "sourceDataProvider");
Assert.ArgumentNotNull(retrySingleItemAction, "retrySingleItemAction");
Assert.ArgumentNotNull(retryTreeAction, "retryTreeAction");
if (_itemFailures.Count > 0)
{
List <Failure> originalItemFailures;
do
{
sourceDataStore.ResetTemplateEngine();
// save existing failures collection
originalItemFailures = new List <Failure>(_itemFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_itemFailures.Clear();
foreach (var failure in originalItemFailures)
{
// retry loading a single item failure
var item = failure.Item;
if (item != null)
{
try
{
retrySingleItemAction(item);
}
catch (Exception reason)
{
_itemFailures.Add(CreateFailure(failure.Item, reason));
}
continue;
}
// retry loading a reference failure (note the continues in the above ensure execution never arrives here for items)
retryTreeAction(failure.Item);
}
} while (_itemFailures.Count > 0 && _itemFailures.Count < originalItemFailures.Count);
// continue retrying until all possible failures have been fixed
}
if (_treeFailures.Count > 0)
{
List <Failure> originalTreeFailures;
do
{
sourceDataStore.ResetTemplateEngine();
// save existing failures collection
originalTreeFailures = new List <Failure>(_treeFailures);
// clear the failures collection - we'll re-add any that fail again by evaluating originalFailures
_treeFailures.Clear();
foreach (var failure in originalTreeFailures)
{
try
{
// retry loading a tree failure
retryTreeAction(failure.Item);
}
catch (Exception reason)
{
_treeFailures.Add(CreateFailure(failure.Item, reason));
}
}
}while (_treeFailures.Count > 0 && _treeFailures.Count < originalTreeFailures.Count); // continue retrying until all possible failures have been fixed
}
if (_itemFailures.Count > 0 || _treeFailures.Count > 0)
{
if (_itemFailures.All(fail => !fail.IsHardFailure) && _treeFailures.All(fail => !fail.IsHardFailure))
{
throw new DeserializationSoftFailureAggregateException("Non-fatal warnings occurred during loading.")
{
InnerExceptions = _itemFailures.Select(fail => fail.Reason).Concat(_treeFailures.Select(fail => fail.Reason)).ToArray()
};
}
var exceptions = new List <DeserializationException>();
foreach (var failure in _itemFailures)
{
exceptions.Add(new DeserializationException(failure.Item.GetDisplayIdentifier(), failure.Item, failure.Reason));
}
foreach (var failure in _treeFailures)
{
exceptions.Add(new DeserializationException($"Tree failed to load: {failure.Item.GetDisplayIdentifier()} (the error may be on a child of this item, see the details below)", failure.Item, failure.Reason));
}
throw new DeserializationAggregateException("Some directories could not be loaded.")
{
InnerExceptions = exceptions.ToArray()
};
}
}
protected virtual void DumpTreeRecursive(IItemData root, IPredicate predicate, ITargetDataStore serializationStore, ISourceDataStore sourceDataStore, ILogger logger)
{
var dump = DumpItemInternal(root, predicate, serializationStore);
if (dump.IsIncluded)
{
foreach (var child in sourceDataStore.GetChildren(root))
{
DumpTreeRecursive(child, predicate, serializationStore, sourceDataStore, logger);
}
}
else
{
logger.Warn("[S] {0} because {1}".FormatWith(root.GetDisplayIdentifier(), dump.Justification));
}
}
//[Fact]
//public void LoadTree_IdentifiesOrphanChildItem()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.Is<ISourceItem[]>(y => y.Contains(root.Children[0]))));
//}
//[Fact]
//public void LoadTree_DoesNotIdentifyValidChildrenAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedChildItem.SetupGet(y => y.DatabaseName).Returns("childflag");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// sourceDataProvider.Setup(x => x.GetItemById("childflag", It.IsAny<ID>())).Returns(root.Children[0]);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_DoesNotIdentifySkippedItemsAsOrphans()
//{
// var root = CreateTestTree(2);
// var serializedRootItem = new FakeItem("Root");
// var predicate = CreateExclusiveTestPredicate(new[] { serializedRootItem }, new[] { root });
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById(It.IsAny<string>(), It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateOrphans(It.IsAny<ISourceItem[]>()), Times.Never());
//}
//[Fact]
//public void LoadTree_UpdatesWhenItemDoesNotExistInSource()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Root");
// serializedRootItem.SetupGet(y => y.DatabaseName).Returns("flag");
// var serializedChildItem = new FakeItem("Child");
// serializedRootItem.Setup(x => x.GetChildItems()).Returns(new[] { serializedChildItem });
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(root)).Returns(serializedRootItem);
// var sourceDataProvider = Substitute.For<ISourceDataProvider>();
// sourceDataProvider.Setup(x => x.GetItemById("flag", It.IsAny<ID>())).Returns(root);
// var evaluator = Substitute.For<IEvaluator>();
// var loader = CreateTestLoader(sourceDataProvider, serializationProvider, predicate, evaluator, null);
// TestLoadTree(loader, serializedRootItem);
// evaluator.Verify(x => x.EvaluateNewSerializedItem(serializedChildItem));
//}
//[Fact]
//public void LoadTree_AbortsWhenConsistencyCheckFails()
//{
// var root = CreateTestTree(1);
// var serializedRootItem = new FakeItem("Test");
// serializedRootItem.Setup(x => x.Deserialize(false)).Returns(root);
// var predicate = CreateInclusiveTestPredicate();
// var serializationProvider = Substitute.For<ITargetDataStore>();
// serializationProvider.Setup(x => x.GetReference(It.IsAny<ISourceItem>())).Returns(serializedRootItem);
// var logger = Substitute.For<ISerializationLoaderLogger>();
// var consistencyChecker = Substitute.For<IConsistencyChecker>();
// consistencyChecker.Setup(x => x.IsConsistent(It.IsAny<IItemData>())).Returns(false);
// var loader = CreateTestLoader(null, serializationProvider, predicate, null, logger);
// Assert.Throws<ConsistencyException>((() => loader.LoadTree(serializedRootItem, Substitute.For<IDeserializeFailureRetryer>(), consistencyChecker)));
//}
private SerializationLoader CreateTestLoader(ISourceDataStore sourceDataStore = null, ITargetDataStore targetDataStore = null, IPredicate predicate = null, IEvaluator evaluator = null, ISyncConfiguration syncConfiguration = null, ISerializationLoaderLogger logger = null)
{
targetDataStore = targetDataStore ?? Substitute.For<ITargetDataStore>();
sourceDataStore = sourceDataStore ?? Substitute.For<ISourceDataStore>();
predicate = predicate ?? CreateInclusiveTestPredicate();
evaluator = evaluator ?? Substitute.For<IEvaluator>();
logger = logger ?? Substitute.For<ISerializationLoaderLogger>();
syncConfiguration = syncConfiguration ?? new TestSyncConfiguration();
var mockLogger2 = Substitute.For<ILogger>();
var pathResolver = new PredicateRootPathResolver(predicate, targetDataStore, sourceDataStore, mockLogger2);
return new SerializationLoader(sourceDataStore, targetDataStore, predicate, evaluator, logger, syncConfiguration, pathResolver);
}
