private IMigrationAction RealizeSingleActionFromEDM(
RTChangeAction runTimeChangeAction)
{
XmlDocument changeActionData = null;
if (!string.IsNullOrEmpty(runTimeChangeAction.ActionData))
{
changeActionData = new XmlDocument();
changeActionData.LoadXml(runTimeChangeAction.ActionData);
}
IMigrationItemSerializer itemSerializer = ManagerWithMigrationItemSerializers[runTimeChangeAction.ActionId];
DemandUnlocked("Cannot Create an action on a group after the initial Create");
SqlMigrationAction migrationAction = new SqlMigrationAction(
this, runTimeChangeAction.ChangeActionId, runTimeChangeAction.ActionId,
itemSerializer.LoadItem(runTimeChangeAction.SourceItem, Manager),
runTimeChangeAction.FromPath, runTimeChangeAction.ToPath, runTimeChangeAction.Version,
runTimeChangeAction.MergeVersionTo, runTimeChangeAction.ItemTypeReferenceName, changeActionData,
runTimeChangeAction.IsSubstituted ? ActionState.Skipped : ActionState.Pending);
if (!m_usePagedActions)
{
AddAction(migrationAction);
}
migrationAction.IsDirty = false;
return(migrationAction);
}
private IMigrationAction CreateAction(
Guid action,
IMigrationItem sourceItem,
string fromPath,
string path,
string version,
string mergeVersionTo,
string itemTypeRefName,
XmlDocument actionDetails,
long internalChangeActionId,
bool isSubstituted)
{
if (!Manager.TargetActionids.ContainsKey(action))
{
// ToDo - Action not supported conflict
}
DemandUnlocked("Cannot Create an action on a group after the initial Create");
SqlMigrationAction createdAction = new SqlMigrationAction(
this, internalChangeActionId, action, sourceItem,
fromPath, path, version, mergeVersionTo, itemTypeRefName, actionDetails,
isSubstituted ? ActionState.Skipped : ActionState.Pending);
this.AddAction(createdAction);
return(createdAction);
}
/// <summary>
/// Realize a SqlMigrationAction from DB RTChangeAction.
/// Note properties ChangeGroup, SourceItem and ActionData are not populated.
/// </summary>
/// <param name="RTChangeAction"></param>
/// <returns></returns>
internal static SqlMigrationAction RealizeFromDB(RTChangeAction RTChangeAction)
{
SqlMigrationAction migrationAction = new SqlMigrationAction(null, RTChangeAction.ChangeActionId, RTChangeAction.ActionId, null, RTChangeAction.FromPath, RTChangeAction.ToPath,
RTChangeAction.Version, RTChangeAction.MergeVersionTo, RTChangeAction.ItemTypeReferenceName, null);
return(migrationAction);
}
public void StorePage(int startIndex, IList <IMigrationAction> page)
{
// Verify that there is something to save and the first change action in the
// page has not been persisted. This implementation relies on page level granularity
// in save/load.
if (page != null && page.Count != 0)
{
SqlMigrationAction sqlMigrationAction = (SqlMigrationAction)page[0];
m_sqlChangeGroupManager.BatchSaveGroupedChangeActions(page);
}
}
private IMigrationAction CreateDeleteAttachmentAction(IMigrationAction action)
{
SqlMigrationAction sqlMigrationAction = action as SqlMigrationAction;
System.Diagnostics.Debug.Assert(null != sqlMigrationAction, "cannot convert action to SqlMigrationAction");
SqlMigrationAction copy = new SqlMigrationAction(
action.ChangeGroup, 0, WellKnownChangeActionId.DelAttachment, action.SourceItem,
action.FromPath, action.Path, action.Version, action.MergeVersionTo, action.ItemTypeReferenceName,
action.MigrationActionDescription, action.State);
return(copy);
}
public override ReadOnlyCollection <KeyValuePair <MigrationAction, MigrationAction> > DetectContentConflict()
{
List <KeyValuePair <MigrationAction, MigrationAction> > conflictActions = new List <KeyValuePair <MigrationAction, MigrationAction> >();
Dictionary <long, SqlChangeGroup> loadedChangeGroups = new Dictionary <long, SqlChangeGroup>();
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
foreach (VCContentConflictResult contentConflictResults in context.QueryContentConflict(SourceId, new Guid(Session.SessionUniqueId)))
{
RTChangeAction migrationInstructionAction =
context.RTChangeActionSet.Where(a => a.ChangeActionId == contentConflictResults.MigrationInstructionChangeActionId).First();
RTChangeAction deltaAction =
context.RTChangeActionSet.Where(a => a.ChangeActionId == contentConflictResults.DeltaChangeActionId).First();
SqlMigrationAction conflictActionSource = SqlMigrationAction.RealizeFromDB(migrationInstructionAction);
if (loadedChangeGroups.ContainsKey(migrationInstructionAction.ChangeGroupId))
{
conflictActionSource.ChangeGroup = loadedChangeGroups[migrationInstructionAction.ChangeGroupId];
}
else
{
RTChangeGroup migrationInstructionChangeGroup = context.RTChangeGroupSet.Where(c => c.Id == migrationInstructionAction.ChangeGroupId).First();
SqlChangeGroup conflictChangeGroupSource = new SqlChangeGroup(this);
conflictChangeGroupSource.RealizeFromEDMWithSingleAction(migrationInstructionChangeGroup, migrationInstructionAction);
loadedChangeGroups.Add(migrationInstructionAction.ChangeGroupId, conflictChangeGroupSource);
conflictActionSource.ChangeGroup = conflictChangeGroupSource;
}
SqlMigrationAction conflictActionTarget = SqlMigrationAction.RealizeFromDB(deltaAction);
if (loadedChangeGroups.ContainsKey(deltaAction.ChangeGroupId))
{
conflictActionTarget.ChangeGroup = loadedChangeGroups[deltaAction.ChangeGroupId];
}
else
{
RTChangeGroup deltaChangeGroup = context.RTChangeGroupSet.Where(c => c.Id == deltaAction.ChangeGroupId).First();
SqlChangeGroup conflictChangeGroupTarget = new SqlChangeGroup(this);
conflictChangeGroupTarget.RealizeFromEDMWithSingleAction(deltaChangeGroup, deltaAction);
loadedChangeGroups.Add(deltaAction.ChangeGroupId, conflictChangeGroupTarget);
conflictActionTarget.ChangeGroup = conflictChangeGroupTarget;
}
conflictActions.Add(new KeyValuePair <MigrationAction, MigrationAction>(conflictActionSource, conflictActionTarget));
}
}
return(conflictActions.AsReadOnly());
}
/// <summary>
/// bulk save sliced child change actions
/// </summary>
/// <param name="page">a page/slice of child change actions</param>
internal void BatchSaveChangeActions(IList <IMigrationAction> page)
{
Debug.Assert(m_runTimeChangeGroup != null);
const int bulkChangeActionInsertionSize = 1000;
int changeActionCount = 0;
int pageIndex = 0;
while (pageIndex < page.Count)
{
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
RTChangeGroup rtChangeGroupCache = getNativeRTChangeGroup(context);
Debug.Assert(null != rtChangeGroupCache);
while (pageIndex < page.Count && changeActionCount < bulkChangeActionInsertionSize)
{
SqlMigrationAction action = page[pageIndex] as SqlMigrationAction;
Debug.Assert(null != action);
// cache "Dirty" flag, as assignin 'this' to its ChangeGroup will set the flag to true
bool actionWasDirty = action.IsDirty;
action.ChangeGroup = this;
if (!action.IsPersisted)
{
IMigrationItemSerializer serializer = ManagerWithMigrationItemSerializers[action.Action];
action.CreateNew(serializer);
context.AddToRTChangeActionSet(action.RTChangeAction);
action.RTChangeAction.ChangeGroup = rtChangeGroupCache;
++changeActionCount;
}
else if (actionWasDirty)
{
IMigrationItemSerializer serializer = ManagerWithMigrationItemSerializers[action.Action];
RTChangeAction rtChangeAction = action.RTChangeAction;
if (null != rtChangeAction)
{
rtChangeAction = context.GetObjectByKey(rtChangeAction.EntityKey) as RTChangeAction;
}
else
{
rtChangeAction = context.RTChangeActionSet.Where(ca => ca.ChangeActionId == action.ActionId).First();
}
rtChangeAction.Recursivity = action.Recursive;
rtChangeAction.IsSubstituted = action.State == ActionState.Skipped ? true : false;
rtChangeAction.ActionId = action.Action;
rtChangeAction.SourceItem = serializer.SerializeItem(action.SourceItem);
rtChangeAction.ToPath = action.Path;
rtChangeAction.ItemTypeReferenceName = action.ItemTypeReferenceName;
rtChangeAction.FromPath = action.FromPath;
rtChangeAction.Version = action.Version;
rtChangeAction.MergeVersionTo = action.MergeVersionTo;
if (action.MigrationActionDescription != null &&
action.MigrationActionDescription.DocumentElement != null)
{
rtChangeAction.ActionData = action.MigrationActionDescription.DocumentElement.OuterXml;
}
++changeActionCount;
}
++pageIndex;
}
context.TrySaveChanges();
changeActionCount = 0;
}
}
}
protected override void Create()
{
// ToDo
ChangeStatus targetStatus = Status;
SqlChangeGroupManager manager = this.Manager as SqlChangeGroupManager;
Debug.Assert(null != manager, "Manager is not a SqlChangeGroupManager for SqlChangeGroup");
// save the group (without child actions)
SavePartialChangeGroup();
// bulk save sliced child change actions
const int bulkChangeActionInsertionSize = 1000;
int changeActionCount = 0;
while (Actions.Count > 0)
{
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
try
{
context.Attach(m_runTimeChangeGroup);
while (Actions.Count > 0 && changeActionCount < bulkChangeActionInsertionSize)
{
SqlMigrationAction action = Actions[0] as SqlMigrationAction;
Debug.Assert(null != action);
action.ChangeGroup = this;
IMigrationItemSerializer serializer = ManagerWithMigrationItemSerializers[action.Action];
action.CreateNew(serializer);
action.RTChangeAction.ChangeGroup = m_runTimeChangeGroup;
// Remove processed child change actions.
// When this ObjectModel context is disposed,
// the RTChangeAction will be disposed as well.
Actions.RemoveAt(0);
++changeActionCount;
}
context.TrySaveChanges();
}
finally
{
context.Detach(m_runTimeChangeGroup);
}
}
changeActionCount = 0;
}
// update group status in DB
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
try
{
context.Attach(m_runTimeChangeGroup);
m_runTimeChangeGroup.Status = (int)targetStatus;
m_runTimeChangeGroup.UsePagedActions = m_usePagedActions;
context.TrySaveChanges();
}
finally
{
context.Detach(m_runTimeChangeGroup);
}
}
}
