private void ParseStoredDomainModel()
{
var context = UpgradeContext;
var extensions = context.Metadata.Extensions.Where(e => e.Name == WellKnown.DomainModelExtensionName);
try {
var found = false;
var types = new List <StoredTypeInfo>();
foreach (var extension in extensions)
{
found = true;
var part = StoredDomainModel.Deserialize(extension.Value);
types.AddRange(part.Types);
}
if (!found)
{
UpgradeLog.Info(Strings.LogDomainModelIsNotFoundInStorage);
return;
}
var model = new StoredDomainModel {
Types = types.ToArray()
};
model.UpdateReferences();
context.ExtractedDomainModel = model;
}
catch (Exception e) {
UpgradeLog.Warning(e, Strings.LogFailedToExtractDomainModelFromStorage);
}
}
public UpgradeHintValidator(StoredDomainModel currentModel, StoredDomainModel extractedModel, Dictionary <StoredTypeInfo, StoredTypeInfo> typeMapping, Dictionary <StoredTypeInfo, StoredTypeInfo> reverseTypeMapping)
{
this.currentModel = currentModel;
this.extractedModel = extractedModel;
this.typeMapping = typeMapping;
this.reverseTypeMapping = reverseTypeMapping;
}
public void SetUp()
{
BuildDomain("1", DomainUpgradeMode.Recreate);
storedModel = domain.Model.ToStoredModel();
storedModel.UpdateReferences();
FillData();
}
// Constructors
public UpgradeHintsProcessor(
HandlerAccessor handlers,
MappingResolver resolver,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel,
StorageModel extractedStorageModel,
bool autoDetectTypesMovements)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
domainModel = handlers.Domain.Model;
this.extractedStorageModel = extractedStorageModel;
currentModel = currentDomainModel;
currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType);
extractedModel = extractedDomainModel;
extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType);
this.autoDetectTypesMovements = autoDetectTypesMovements;
hints = new NativeTypeClassifier <UpgradeHint>(true);
suspiciousTypes = new List <StoredTypeInfo>();
}
public void MainTest()
{
var model = Domain.Model.ToStoredModel();
var serialized = model.Serialize();
var result = StoredDomainModel.Deserialize(serialized);
result.UpdateReferences();
}
private List <StoredTypeInfo> GetMovedTypes(StoredDomainModel model)
{
return((
from type in GetNonConnectorTypes(model)
where type.IsEntity && (!type.IsAbstract) && (!type.IsGeneric) && (!type.IsInterface)
where IsMovedToAnotherHierarchy(type)
select type
).ToList());
}
private static IEnumerable <StoredTypeInfo> GetNonConnectorTypes(StoredDomainModel model)
{
var connectorTypes = (
from association in model.Associations
let type = association.ConnectorType
where type != null
select type
).ToHashSet();
return(model.Types.Where(type => !connectorTypes.Contains(type)));
}
private static IReadOnlyList <StoredTypeInfo> GetNonConnectorTypes(StoredDomainModel model)
{
var connectorTypes = (
from association in model.Associations
let type = association.ConnectorType
where type != null
select type
).ToHashSet();
return(model.Types
.Where(type => !connectorTypes.Contains(type))
.ToArray(model.Types.Length - connectorTypes.Count));
}
private IUpgradeHintsProcessor GetHintProcessor(StoredDomainModel currentDomainModel, StorageModel extractedSchema, HandlerAccessor handlers)
{
var oldModel = context.ExtractedDomainModel;
var stage = context.Stage;
if (stage == UpgradeStage.Upgrading && oldModel != null)
{
return(new UpgradeHintsProcessor(handlers, context.Services.MappingResolver, currentDomainModel, oldModel, extractedSchema, context.TypesMovementsAutoDetection));
}
if (context.UpgradeMode == DomainUpgradeMode.Validate && oldModel != null)
{
return(new UpgradeHintsProcessor(handlers, context.Services.MappingResolver, currentDomainModel, oldModel, extractedSchema, false));
}
return(new NullUpgradeHintsProcessor(currentDomainModel));
}
public void MappingNameTest()
{
var initialConfiguration = DomainConfigurationFactory.Create();
initialConfiguration.Types.Register(typeof(EntityWithState));
initialConfiguration.Types.Register(typeof(FieldNamesModifier));
initialConfiguration.Types.Register(typeof(CustomUpgradeHandler));
initialConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
Domain domain = null;
using (domain = Domain.Build(initialConfiguration)) {
var metadata = domain.Extensions.Get <MetadataSet>();
var savedModel = StoredDomainModel.Deserialize(metadata.Extensions.First().Value);
var type = savedModel.Types.First(t => t.Name == "EntityWithState");
var stateField = type.Fields.First(f => f.PropertyName == "State");
Assert.That(stateField.Name, Is.Not.EqualTo(stateField.PropertyName));
Assert.That(stateField.MappingName, Is.Not.EqualTo(stateField.PropertyName));
Assert.That(stateField.OriginalName, Is.Not.EqualTo(stateField.PropertyName));
Assert.That(stateField.Name, Is.EqualTo("EntityWithState.State"));
Assert.That(stateField.MappingName, Is.EqualTo(stateField.Name));
Assert.That(stateField.OriginalName, Is.EqualTo(stateField.Name));
}
var upgradeConfiguration = DomainConfigurationFactory.Create();
upgradeConfiguration.Types.Register(typeof(EntityWithState));
upgradeConfiguration.Types.Register(typeof(MappingNameModifier));
upgradeConfiguration.Types.Register(typeof(CustomUpgradeHandler));
upgradeConfiguration.UpgradeMode = DomainUpgradeMode.PerformSafely;
Assert.DoesNotThrow(() => domain = Domain.Build(upgradeConfiguration));
using (domain) {
var metadata = domain.Extensions.Get <MetadataSet>();
var savedModel = StoredDomainModel.Deserialize(metadata.Extensions.First().Value);
var type = savedModel.Types.First(t => t.Name == "EntityWithState");
var stateField = type.Fields.First(f => f.PropertyName == "State");
Assert.That(stateField.Name, Is.EqualTo(stateField.PropertyName));
Assert.That(stateField.OriginalName, Is.EqualTo(stateField.PropertyName));
Assert.That(stateField.MappingName, Is.EqualTo("EntityWithState.State"));
}
}
public void UpdateMappings(StoredDomainModel model, NodeConfiguration nodeConfiguration)
{
ArgumentValidator.EnsureArgumentNotNull(model, "model");
ArgumentValidator.EnsureArgumentNotNull(nodeConfiguration, "nodeConfiguration");
foreach (var storedType in model.Types)
{
if (!storedType.MappingDatabase.IsNullOrEmpty())
{
storedType.MappingDatabase = nodeConfiguration.DatabaseMapping.Apply(storedType.MappingDatabase);
}
if (!storedType.MappingSchema.IsNullOrEmpty())
{
storedType.MappingSchema = nodeConfiguration.SchemaMapping.Apply(storedType.MappingSchema);
}
}
}
// Constructors
public UpgradeHintsProcessor(
HandlerAccessor handlers,
MappingResolver resolver,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel,
StorageModel extractedStorageModel,
bool autoDetectTypesMovements)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers));
ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver));
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel));
// since type mapping is intersection of current types and extracted types
// it will be equal or less than min size of these two sets
var typesCapacity = currentDomainModel.Types.Length > extractedDomainModel.Types.Length
? extractedDomainModel.Types.Length
: currentDomainModel.Types.Length;
// By setting capacity we eliminate resize work and memory fluctuations.
// In the worst case, when almost all types don't intersect, we will have some waste of memory
// but in real life this is very rare case.
typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity);
reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity);
fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
domainModel = handlers.Domain.Model;
this.extractedStorageModel = extractedStorageModel;
currentModel = currentDomainModel;
currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, currentModel.Types.Length);
extractedModel = extractedDomainModel;
extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, extractedModel.Types.Length);
this.autoDetectTypesMovements = autoDetectTypesMovements;
hints = new NativeTypeClassifier <UpgradeHint>(true);
suspiciousTypes = new HashSet <StoredTypeInfo>();
}
// Constructors
public HintGenerator(Dictionary <StoredTypeInfo, StoredTypeInfo> typeMapping,
Dictionary <StoredTypeInfo, StoredTypeInfo> reverseTypeMapping,
Dictionary <StoredFieldInfo, StoredFieldInfo> fieldMapping,
NativeTypeClassifier <UpgradeHint> hints,
HandlerAccessor handlers,
MappingResolver resolver,
StorageModel extractedStorageModel,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel)
{
ArgumentValidator.EnsureArgumentNotNull(typeMapping, "typeMapping");
ArgumentValidator.EnsureArgumentNotNull(reverseTypeMapping, "reverseTypeMapping");
ArgumentValidator.EnsureArgumentNotNull(fieldMapping, "fieldMapping");
ArgumentValidator.EnsureArgumentNotNull(hints, "hints");
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
this.typeMapping = typeMapping;
this.reverseTypeMapping = reverseTypeMapping;
this.fieldMapping = fieldMapping;
this.hints = hints;
extractedModelFields = new Dictionary <StoredTypeInfo, StoredFieldInfo[]>();
this.extractedStorageModel = extractedStorageModel;
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
currentModel = currentDomainModel;
currentModel.UpdateReferences();
extractedModel = extractedDomainModel;
foreach (var type in extractedModel.Types)
{
extractedModelFields.Add(type, type.Fields.Flatten(f => f.Fields, null, true).ToArray());
}
}
// Constructors
public HintGenerator(UpgradeHintsProcessingResult hintsProcessingResult,
HandlerAccessor handlers,
MappingResolver resolver,
StorageModel extractedStorageModel,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel)
{
ArgumentValidator.EnsureArgumentNotNull(hintsProcessingResult, nameof(hintsProcessingResult));
ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers));
ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver));
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel));
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel));
typeMapping = hintsProcessingResult.TypeMapping;
reverseTypeMapping = hintsProcessingResult.ReverseTypeMapping;
fieldMapping = hintsProcessingResult.FieldMapping;
hints = hintsProcessingResult.Hints;
suspiciousTypes = hintsProcessingResult.SuspiciousTypes;
currentNonConnectorTypes = hintsProcessingResult.CurrentNonConnectorTypes;
extractedNonConnectorTypes = hintsProcessingResult.ExtractedNonConnectorTypes;
this.extractedStorageModel = extractedStorageModel;
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
currentModel = currentDomainModel;
currentModel.UpdateReferences();
extractedModelFields = new Dictionary <StoredTypeInfo, StoredFieldInfo[]>();
extractedModel = extractedDomainModel;
foreach (var type in extractedModel.Types)
{
extractedModelFields.Add(type, type.Fields.Flatten(f => f.Fields, null, true).ToArray());
}
}
//private HintSet GetSchemaHints(StorageModel extractedSchema, StorageModel targetSchema)
//{
// context.SchemaHints = new HintSet(extractedSchema, targetSchema);
// if (context.Stage==UpgradeStage.Upgrading)
// BuildSchemaHints(extractedSchema);
// return context.SchemaHints;
//}
private void BuildSchemaHints(StorageModel extractedSchema, UpgradeHintsProcessingResult result, StoredDomainModel currentDomainModel)
{
var oldModel = context.ExtractedDomainModel;
if (oldModel == null)
{
return;
}
var handlers = Domain.Demand().Handlers;
// It's important to use same StoredDomainModel of current domain
// in both UpgradeHintsProcessor and HintGenerator instances.
var hintGenerator = new HintGenerator(result.TypeMapping, result.ReverseTypeMapping, result.FieldMapping, result.Hints, handlers, context.Services.MappingResolver, extractedSchema, currentDomainModel, oldModel);
var hints = hintGenerator.Run();
context.UpgradedTypesMapping = hints.UpgradedTypesMapping;
context.Hints.Clear();
foreach (var modelHint in hints.ModelHints)
{
context.Hints.Add(modelHint);
}
foreach (var schemaHint in hints.SchemaHints)
{
try {
context.SchemaHints.Add(schemaHint);
}
catch (Exception error) {
UpgradeLog.Warning(Strings.LogFailedToAddSchemaHintXErrorY, schemaHint, error);
}
}
}
public NullUpgradeHintsProcessor(StoredDomainModel currentDomainModel)
{
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
this.currentDomainModel = currentDomainModel;
}
public NullUpgradeHintsProcessor(StoredDomainModel currentDomainModel)
{
this.currentDomainModel = currentDomainModel;
}
public static ClassifiedCollection <string, Pair <string, string[]> > GetGenericTypes(StoredDomainModel model)
{
var genericTypes = new ClassifiedCollection <string, Pair <string, string[]> >(pair => new[] { pair.First });
foreach (var typeInfo in model.Types.Where(type => type.IsGeneric))
{
var typeDefinitionName = typeInfo.GenericTypeDefinition;
genericTypes.Add(new Pair <string, string[]>(typeDefinitionName, typeInfo.GenericArguments));
}
return(genericTypes);
}
