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); }