private static void WriteSchemaModifications(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter writer, List <PropertySet> modifiedPropertySets)
{
// #1: Delete types
foreach (NodeType type in GetNodeTypeRootsToDelete(origSchema.NodeTypes, newSchema.NodeTypes))
{
WriteDeleteNodeType(writer, type, origSchema, modifiedPropertySets);
}
foreach (var type in GetTypesToDelete <ContentListType>(origSchema.ContentListTypes, newSchema.ContentListTypes))
{
WriteDeleteContentListType(writer, type, origSchema, modifiedPropertySets);
}
// #2: Create or modify types
WriteCreateOrModifyPropertyTypes(origSchema, newSchema, writer);
WriteCreateOrModifyNodeTypes(origSchema, newSchema, modifiedPropertySets, writer);
WriteCreateOrModifyContentListTypes(origSchema, newSchema, modifiedPropertySets, writer);
// #3: Delete PropertyTypes
foreach (PropertyType type in GetTypesToDelete <PropertyType>(origSchema.PropertyTypes, newSchema.PropertyTypes))
{
WriteDeletePropertyType(writer, type);
}
}
private static void RegisterSchema(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter schemaWriter)
{
using (var op = SnTrace.Database.StartOperation("Write storage schema modifications."))
{
// Ensure transaction encapsulation
bool isLocalTransaction = !TransactionScope.IsActive;
if (isLocalTransaction)
{
TransactionScope.Begin();
}
try
{
List <PropertySet> modifiedPropertySets = new List <PropertySet>();
schemaWriter.Open();
WriteSchemaModifications(origSchema, newSchema, schemaWriter, modifiedPropertySets);
foreach (PropertySet modifiedPropertySet in modifiedPropertySets)
{
NodeTypeDependency.FireChanged(modifiedPropertySet.Id);
}
schemaWriter.Close();
if (isLocalTransaction)
{
TransactionScope.Commit();
}
ActiveSchema.Reset();
op.Successful = true;
}
catch (Exception ex)
{
SnLog.WriteException(ex, null, EventId.RepositoryRuntime);
throw new SchemaEditorCommandException("Error during schema registration.", ex);
}
finally
{
IDisposable unmanagedWriter = schemaWriter as IDisposable;
if (unmanagedWriter != null)
{
unmanagedWriter.Dispose();
}
try
{
if (isLocalTransaction && TransactionScope.IsActive)
{
TransactionScope.Rollback();
}
}
catch (Exception ex2)
{
// This catch block will handle any errors that may have occurred
// on the server that would cause the rollback to fail, such as
// a closed connection (MSDN).
const string msg = "Error during schema transaction rollback.";
SnLog.WriteException(ex2, msg, EventId.RepositoryRuntime);
throw new SchemaEditorCommandException(msg, ex2);
}
}
}
}
public void Register()
{
SchemaEditor origSchema = new SchemaEditor();
origSchema.Load();
DataProvider.Current.AssertSchemaTimestampAndWriteModificationDate(this.SchemaTimestamp);
SchemaWriter schemaWriter = DataProvider.Current.CreateSchemaWriter();
RegisterSchema(origSchema, this, schemaWriter);
}
private static void RegisterSchema(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter schemaWriter)
{
if (schemaWriter.CanWriteDifferences)
{
using (var op = SnTrace.Database.StartOperation("Write storage schema modifications."))
{
try
{
var modifiedPropertySets = new List <PropertySet>();
schemaWriter.Open();
WriteSchemaModifications(origSchema, newSchema, schemaWriter, modifiedPropertySets);
foreach (var modifiedPropertySet in modifiedPropertySets)
{
NodeTypeDependency.FireChanged(modifiedPropertySet.Id);
}
schemaWriter.Close();
ActiveSchema.Reset();
op.Successful = true;
}
catch (Exception ex)
{
SnLog.WriteException(ex, null, EventId.RepositoryRuntime);
throw new SchemaEditorCommandException("Error during schema registration.", ex);
}
finally
{
if (schemaWriter is IDisposable unmanagedWriter)
{
unmanagedWriter.Dispose();
}
}
}
}
else
{
using (var op = SnTrace.Database.StartOperation("Update storage schema."))
{
var modifiedPropertySetIds = GetModifiedPropertySetIds(origSchema, newSchema);
schemaWriter.WriteSchemaAsync(newSchema.ToRepositorySchemaData()).GetAwaiter().GetResult();
ActiveSchema.Reset();
foreach (var id in modifiedPropertySetIds)
{
NodeTypeDependency.FireChanged(id);
}
op.Successful = true;
}
}
}
private static void WriteCreateOrModifyContentListTypes(SchemaEditor origSchema, SchemaEditor newSchema, List <PropertySet> modifiedPropertySets, SchemaWriter writer)
{
foreach (var newType in newSchema.ContentListTypes)
{
if (NeedToCreate <ContentListType>(origSchema.ContentListTypes, newType))
{
writer.CreateContentListType(newType.Name);
}
WriteAddOrRemovePropertyTypes(origSchema.ContentListTypes[newType.Name], newType, modifiedPropertySets, writer);
}
}
// -------------------------------------------------------------- CreateOrRemove commands
private static void WriteCreateOrModifyPropertyTypes(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter writer)
{
// new
foreach (PropertyType newType in newSchema.PropertyTypes)
{
if (NeedToCreate <PropertyType>(origSchema.PropertyTypes, newType))
{
writer.CreatePropertyType(newType.Name, newType.DataType, newType.Mapping, newType.IsContentListProperty);
}
}
}
private static void WriteCreateOrModifyPermissionTypes(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter writer)
{
//-- new
foreach (PermissionType newType in newSchema.PermissionTypes)
{
if (NeedToCreate <PermissionType>(origSchema.PermissionTypes, newType))
{
writer.CreatePermissionType(newType.Name);
}
}
}
private static void WriteCreateOrModifyNodeTypes(SchemaEditor origSchema, SchemaEditor newSchema, List <PropertySet> modifiedPropertySets, SchemaWriter writer)
{
List <NodeType> _nodeTypesToEnumerate = new List <NodeType>();
// collect only roots
foreach (NodeType rootNodeType in newSchema.NodeTypes)
{
if (rootNodeType.Parent == null)
{
_nodeTypesToEnumerate.Add(rootNodeType);
}
}
int index = 0;
while (index < _nodeTypesToEnumerate.Count)
{
NodeType currentType = _nodeTypesToEnumerate[index++];
NodeType origType = null;
if (NeedToCreate <NodeType>(origSchema.NodeTypes, currentType))
{
if (currentType.ClassName == null)
{
throw new InvalidSchemaException("ClassName cannot be null. NodeType: " + currentType.Name);
}
writer.CreateNodeType(currentType.Parent, currentType.Name, currentType.ClassName);
}
else
{
origType = origSchema.NodeTypes[currentType.Name];
string origParentName = origType.Parent == null ? null : origType.Parent.Name;
string newParentName = currentType.Parent == null ? null : currentType.Parent.Name;
bool parentChanged = origParentName != newParentName;
if (parentChanged || origType.ClassName != currentType.ClassName)
{
writer.ModifyNodeType(origType, currentType.Parent, currentType.ClassName);
if (!modifiedPropertySets.Contains(origType))
{
modifiedPropertySets.Add(origType);
}
}
}
// Property list (origType can be null)
WriteAddOrRemovePropertyTypes(origType, currentType, modifiedPropertySets, writer);
// Add children to enumerator
_nodeTypesToEnumerate.AddRange(currentType.GetChildren());
}
}
public void Register()
{
var origSchema = Retrier.Retry(3, 100, typeof(InvalidSchemaException), () =>
{
var sche = new SchemaEditor();
sche.Load();
return(sche);
});
DataProvider.Current.AssertSchemaTimestampAndWriteModificationDate(this.SchemaTimestamp);
SchemaWriter schemaWriter = DataProvider.Current.CreateSchemaWriter();
RegisterSchema(origSchema, this, schemaWriter);
}
private static void RegisterSchema(SchemaEditor origSchema, SchemaEditor newSchema, SchemaWriter schemaWriter)
{
using (var traceOperation = Logger.TraceOperation("Write storage schema modifications."))
{
// Ensure transaction encapsulation
bool isLocalTransaction = !TransactionScope.IsActive;
if (isLocalTransaction)
{
TransactionScope.Begin();
}
try
{
List <PropertySet> modifiedPropertySets = new List <PropertySet>();
schemaWriter.Open();
WriteSchemaModifications(origSchema, newSchema, schemaWriter, modifiedPropertySets);
foreach (PropertySet modifiedPropertySet in modifiedPropertySets)
{
NodeTypeDependency.FireChanged(modifiedPropertySet.Id);
}
schemaWriter.Close();
if (isLocalTransaction)
{
TransactionScope.Commit();
}
ActiveSchema.Reset();
traceOperation.IsSuccessful = true;
}
finally
{
IDisposable unmanagedWriter = schemaWriter as IDisposable;
if (unmanagedWriter != null)
{
unmanagedWriter.Dispose();
}
if (isLocalTransaction && TransactionScope.IsActive)
{
TransactionScope.Rollback();
}
}
}
}
public void Register()
{
var origSchema = Retrier.Retry(3, 100, typeof(InvalidSchemaException), () =>
{
var sche = new SchemaEditor();
sche.Load();
return(sche);
});
var schemaLock = DataStore.StartSchemaUpdateAsync(this.SchemaTimestamp, CancellationToken.None).GetAwaiter().GetResult();
var schemaWriter = DataStore.CreateSchemaWriter();
try
{
RegisterSchema(origSchema, this, schemaWriter);
}
finally
{
DataStore.FinishSchemaUpdateAsync(schemaLock, CancellationToken.None).GetAwaiter().GetResult();
}
}
private static IEnumerable <int> GetModifiedPropertySetIds(SchemaEditor origSchema, SchemaEditor newSchema)
{
var origTypes = origSchema.NodeTypes;
var newTypes = newSchema.NodeTypes;
var origIds = origTypes.Select(x => x.Id).ToArray();
var newIds = newTypes.Select(x => x.Id).ToArray();
var deletedIds = origIds.Except(newIds).ToArray();
var canBeModifiedIds = origIds.Intersect(newIds).ToArray();
var modifiedIds = new List <int>();
foreach (var id in canBeModifiedIds)
{
var orig = GetControlString(origTypes.GetItemById(id));
var @new = GetControlString(newTypes.GetItemById(id));
if (orig != @new)
{
modifiedIds.Add(id);
}
}
return(deletedIds.Union(modifiedIds));
}
private static void WriteDeleteContentListType(SchemaWriter writer, ContentListType contentListType, SchemaEditor origSchema, List <PropertySet> modifiedPropertySets)
{
writer.DeleteContentListType(contentListType);
if (!modifiedPropertySets.Contains(contentListType))
{
modifiedPropertySets.Add(contentListType);
}
}
private static void WriteDeleteNodeType(SchemaWriter writer, NodeType nodeType, SchemaEditor origSchema, List <PropertySet> modifiedPropertySets)
{
// recursive
foreach (NodeType childType in nodeType.Children)
{
WriteDeleteNodeType(writer, childType, origSchema, modifiedPropertySets);
}
writer.DeleteNodeType(nodeType);
if (!modifiedPropertySets.Contains(nodeType))
{
modifiedPropertySets.Add(nodeType);
}
}