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);
}
public void RegisterMigrationItemSerializer(Guid changeActionType, IMigrationItemSerializer serializer)
{
if (this.m_serializer.ContainsKey(changeActionType))
{
m_serializer.Remove(changeActionType);
}
m_serializer.Add(changeActionType, serializer);
}
/// <summary>
/// Return a service based on serviceType.
/// </summary>
/// <param name="serviceType"></param>
/// <returns></returns>
public object GetService(Type serviceType)
{
if (serviceType == typeof(IAnalysisProvider))
{
if (m_analysisProvider == null)
{
m_analysisProvider = new TfsFileSystemAnalysisProvider();
}
return(m_analysisProvider);
}
else if (serviceType == typeof(IServerPathTranslationService))
{
if (m_serverPathTranslationProvider == null)
{
m_serverPathTranslationProvider = new TfsFileSystemTranslationService();
}
return(m_serverPathTranslationProvider);
}
else if (serviceType == typeof(IMigrationProvider))
{
if (m_migrationProvider == null)
{
m_migrationProvider = new TfsFileSystemMigrationProvider();
}
return(m_migrationProvider);
}
else if (serviceType == typeof(IVCDiffProvider))
{
if (m_diffProvider == null)
{
m_diffProvider = new TfsFileSystemDiffProvider();
}
return(m_diffProvider);
}
else if (serviceType == typeof(ISyncMonitorProvider))
{
if (m_syncMonitorProvider == null)
{
m_syncMonitorProvider = new TfsFileSystemSyncMonitorProvider();
}
return(m_syncMonitorProvider);
}
else if (serviceType == typeof(IMigrationItemSerializer))
{
if (m_migrationItemSerializer == null)
{
m_migrationItemSerializer = new TfsFileSystemMigrationItemSerializer();
}
return(m_migrationItemSerializer);
}
return(null);
}
/// <summary> /// Creates a new migration action instance using a default transaction. /// </summary> internal abstract void CreateNew(IMigrationItemSerializer serializer);
/// <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);
}
}
}
public void RegisterDefaultSerializer(IMigrationItemSerializer defaultSerializer)
{
m_defaultSerializer = defaultSerializer;
}
/// <summary>
/// Registers a source serializer for a ContentType with the ChangeGroupManager.
/// </summary>
/// <param name="type">The ContentType id</param>
/// <param name="serializer">The IMigrationItemSerializer to register for the specified ContentType</param>
/// <seealso cref="Microsoft.TeamFoundation.Migration.Toolkit.IMigrationItemSerializer"/>
/// <seealso cref="Microsoft.TeamFoundation.Migration.Toolkit.Services.ContentType"/>
/// <seealso cref="Microsoft.TeamFoundation.Migration.Toolkit.Services.WellKnownContentType"/>
public void RegisterSourceSerializer(Guid type, IMigrationItemSerializer serializer)
{
m_changeGroupManager.RegisterMigrationItemSerializer(type, serializer);
}
/// <summary>
/// Registers the specified IMigrationItemSerializer as the default source serializer with the ChangeGroupManager.
/// </summary>
/// <param name="serializer">The serializer to register</param>
/// <seealso cref="Microsoft.TeamFoundation.Migration.Toolkit.IMigrationItemSerializer"/>
public void RegisterDefaultSourceSerializer(IMigrationItemSerializer serializer)
{
m_changeGroupManager.RegisterDefaultSerializer(serializer);
}
internal override void CreateNew(IMigrationItemSerializer serializer)
{
// TODO: Consider renaming local RTChangeAction property to avoid conflict
if (null == serializer)
{
throw new InvalidOperationException("IMigrationItem serializer is not registered");
}
m_RTChangeAction = Microsoft.TeamFoundation.Migration.EntityModel.RTChangeAction.CreateRTChangeAction
(ChangeGroup.ChangeGroupId, ActionId, Recursive, (State == ActionState.Skipped), 1, Action,
serializer.SerializeItem(SourceItem), Path, false, ItemTypeReferenceName);
m_RTChangeAction.FromPath = FromPath;
m_RTChangeAction.Version = this.Version;
m_RTChangeAction.MergeVersionTo = this.MergeVersionTo;
if (MigrationActionDescription != null && MigrationActionDescription.DocumentElement != null)
{
m_RTChangeAction.ActionData = MigrationActionDescription.DocumentElement.OuterXml;
}
m_RTChangeAction.PropertyChanged +=
new System.ComponentModel.PropertyChangedEventHandler(RTChangeAction_PropertyChanged);
/*
* Debug.Assert(ActionId == -1);
*
* MigrationSqlTransaction sqlTrx = (MigrationSqlTransaction)trx;
*
* using (SqlCommand cmd = sqlTrx.CreateCommand())
* {
* cmd.CommandType = CommandType.StoredProcedure;
* cmd.CommandText = "prc_iiCreateActionData";
*
* cmd.Parameters.Add("@ChangeGroupID", SqlDbType.Int).Value = ChangeGroup.ChangeGroupId;
*
* cmd.Parameters.Add("@Order", SqlDbType.Int).Value = Order;
*
* cmd.Parameters.Add("@State", SqlDbType.Int).Value = State;
*
* cmd.Parameters.Add("@SourceItem", SqlDbType.Xml).Value
* = (SourceItem != null) ? (object)ChangeGroup.Manager.SourceSerializer.SerializeItem(SourceItem) : (object)DBNull.Value;
*
* cmd.Parameters.Add("@TargetSourceItem", SqlDbType.Xml).Value
* = (TargetSourceItem != null) ? (object)ChangeGroup.Manager.TargetSerializer.SerializeItem(TargetSourceItem) : (object)DBNull.Value;
*
* cmd.Parameters.Add("@TargetTargetItem", SqlDbType.Xml).Value
* = (TargetTargetItem != null) ? (object)ChangeGroup.Manager.TargetSerializer.SerializeItem(TargetTargetItem) : (object)DBNull.Value;
*
* cmd.Parameters.Add("@BasicAction", SqlDbType.Int).Value = Action;
* cmd.Parameters.Add("@Recursivity", SqlDbType.Bit).Value = Recursive;
*
* cmd.Parameters.Add("@Label", SqlDbType.NVarChar).Value
* = (Label != null) ? Label : (object)DBNull.Value;
*
* cmd.Parameters.Add("@Version", SqlDbType.NVarChar).Value
* = (Version != null) ? Version : (object)DBNull.Value;
*
* cmd.Parameters.Add("@MergeVersionTo", SqlDbType.NVarChar).Value
* = (MergeVersionTo != null) ? MergeVersionTo : (object)DBNull.Value;
*
* int identity;
* if (DataAccessManager.TryExecuteScalar<int>(cmd, out identity))
* {
* ActionId = identity;
* }
* else
* {
* throw new MigrationException(MigrationToolkitResources.FailureCreatingNewActionRow);
* }
* }*/
}
public ClearCaseMigrationProvider()
{
m_alternativeSerializer = null;
m_hwmLastSyncedTfsChangeset = null;
}
/// <summary>
/// Constructor.
/// Initialize a clearCaseV6MigrationProvider with an alternative serializer.
/// This is used for ClearTFSAdapter
/// </summary>
/// <param name="alternativeSerializer"></param>
public ClearCaseMigrationProvider(IMigrationItemSerializer alternativeSerializer, string hwmName)
{
m_alternativeSerializer = alternativeSerializer;
m_hwmLastSyncedTfsChangeset = new HighWaterMark <int>(hwmName);
}
