private IEnumerator StartSession()
{
yield return(new WaitForSeconds(2f));
RTSession.Connect();
lobbyManager.gameObject.SetActive(false);
}
private IEnumerator SendPackets()
{
for (var i = 1; i <= 150; i++)
{
RTSession.SendData(1, GameSparksRT.DeliveryIntent.RELIABLE, new RTData().SetInt(1, i));
yield return(new WaitForSeconds(2f));
}
}
public void OnEndChat()
{
chatManager.gameObject.SetActive(false);
lobbyManager.gameObject.SetActive(true);
lobbyManager.UpdatePlayersCount(0);
RTSession.Disconnect();
FindPlayers();
}
private void OnMatchFoundMessage(MatchFoundMessage msg)
{
players.Clear();
players.AddRange(msg.Participants.Where(p => p.PeerId != null).Select(p => new PlayerInfo {
DisplaName = p.DisplayName, Id = p.Id, Peer = (int)p.PeerId, OnLine = true
}));
RTSession.Configure(msg, OnPlayerConnect, OnPlayerDisconnect, OnReady, OnRTPacket);
lobbyManager.UpdatePlayersCount(players.Count);
StartCoroutine(StartSession());
}
private RTSessionGroup FindSessionGroupForConflictedAction(
RuntimeEntityModel context,
RTSession rtSession)
{
// find the change group that contains the session
var sessionGroupQuery =
from s in context.RTSessionSet
where s.SessionUniqueId.Equals(rtSession.SessionUniqueId)
select s.SessionGroup;
Debug.Assert(sessionGroupQuery.Count() != 0, "session has no parent session group");
Debug.Assert(sessionGroupQuery.Count() == 1, "session has multiple parent session group");
return(sessionGroupQuery.First());
}
private Session FindSession(Guid sessionGuid, SessionTypeEnum expectedSessionType)
{
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
var sessionQuery =
(from rts in context.RTSessionSet
where rts.SessionUniqueId == sessionGuid
select rts);
if (sessionQuery.Count() == 0)
{
return(null);
}
RTSession rtSession = sessionQuery.First();
rtSession.SessionGroupReference.Load();
return(GetSessionFromSessionGroup(rtSession.SessionGroup.GroupUniqueId, expectedSessionType));
}
}
/// <summary>
/// Marks a non-syncworkflow session to be completed
/// and the parent session group to be completed if all its child
/// sessions are in "completed (3)" status
/// </summary>
private void MigrationSessionCompleted()
{
// update the session state to Completed
//
// NOTE:
// The sproc called here through EDM sets the Session *Group* to
// be completed if all the sibling sessions of the current session (inclusively)
// are completed.
var updatedRTSessions = m_context.UpdateMigrationSessionStatusToCompleted(SessionId);
if (updatedRTSessions.Count() > 0 &&
WorkFlowType.Frequency == Frequency.OneTime)
{
// mark Session Group to be OneTimeCompleted (value: 4)
// Note: updatedRTSessions has already been enumerated in the EDM imported function UpdateMigrationSessionStatusToCompleted
// We have to ask the Context for a new instance of the RTSession, rather than enumerating on updatedRTSessions
RTSession rtSession = m_context.RTSessionSet.Where(s => s.SessionUniqueId.Equals(SessionId)).First();
rtSession.SessionGroupReference.Load();
if (rtSession.SessionGroup.State == (int)BusinessModelManager.SessionStateEnum.Completed)
{
rtSession.SessionGroup.State = (int)BusinessModelManager.SessionStateEnum.OneTimeCompleted;
m_context.TrySaveChanges();
}
}
// update the session sync orchestration state
if (m_syncStateMachine.TryTransit(PipelineSyncCommand.STOP))
{
m_syncStateMachine.CommandTransitFinished(PipelineSyncCommand.STOP);
}
var rtSessionRun = m_context.RTSessionRunSet.Where(r => r.Id == m_sessionRunId).FirstOrDefault();
if (null != rtSessionRun)
{
rtSessionRun.State = (int)BusinessModelManager.SessionStateEnum.Completed;
m_context.TrySaveChanges();
}
}
/// <summary>
/// Gets the current state of the state machine.
/// </summary>
/// <param name="ownerType">The type, session or session group, that this state machine represents.</param>
/// <param name="ownerUniqueId">The GUID used as the unique Id for the subject session or session group.</param>
/// <returns>The current state of the subject session or session group.</returns>
public PipelineState GetCurrentState(OwnerType ownerType, Guid ownerUniqueId)
{
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
switch (ownerType)
{
case OwnerType.Session:
var sessionQuery = context.RTSessionSet.Where(s => s.SessionUniqueId.Equals(ownerUniqueId));
RTSession session = sessionQuery.FirstOrDefault();
if (session != null && session.OrchestrationStatus.HasValue)
{
return((PipelineState)session.OrchestrationStatus.Value);
}
else
{
return(PipelineState.Default);
}
case OwnerType.SessionGroup:
var sessionGroupQuery = context.RTSessionGroupSet.Where(sg => sg.GroupUniqueId.Equals(ownerUniqueId));
RTSessionGroup sessionGroup = sessionGroupQuery.FirstOrDefault();
if (sessionGroup != null && sessionGroup.OrchestrationStatus.HasValue)
{
return((PipelineState)sessionGroupQuery.First().OrchestrationStatus.Value);
}
else
{
return(PipelineState.Default);
}
default:
Debug.Assert(false, "Invalid OwnerType");
throw new InvalidOperationException("Invalid OwnerType");
}
}
}
private IQueryable <RTForceSyncItem> GetRTForceSyncItems(RuntimeEntityModel context)
{
var sessionQuery =
(from session in context.RTSessionSet
where session.SessionUniqueId == SessionId
select session);
if (sessionQuery.Count() > 0)
{
RTSession rtSession = sessionQuery.First();
var forceSyncItemQuery =
(from forceSyncItem in context.RTForceSyncItemSet
where forceSyncItem.SessionId == rtSession.Id &&
forceSyncItem.MigrationSource.UniqueId == MigrationSourceid &&
((!(forceSyncItem.Status.HasValue)) || forceSyncItem.Status != (int)ForceSyncItemStatus.Complete)
select forceSyncItem);
return(forceSyncItemQuery);
}
else
{
return(null);
}
}
public Endpoint(
MonitorWatcher watcher,
RuntimeEntityModel context,
RTSession rtSession,
RTMigrationSource rtMigrationSource,
bool isRightMigrationSource,
RTMigrationSource peerMigrationSource)
{
m_monitorWatcher = watcher;
// TODO: Consider moving all of this initialization code to a new EndpointContext class that contains everything that the
// Poll() method needs to do its job, and then have MonitorWatcher.GetEndpoints() pass the EndpointContext object as the single
// arg to this constructor.
this.Context = context;
this.RTMigrationSource = rtMigrationSource;
this.IsRightMigrationSource = isRightMigrationSource;
this.PeerRTMigrationSource = peerMigrationSource;
BusinessModelManager businessModelManager = new BusinessModelManager();
if (rtSession.SessionGroup == null)
{
rtSession.SessionGroupReference.Load();
}
Config = businessModelManager.LoadConfiguration(rtSession.SessionGroup.GroupUniqueId);
if (Config == null)
{
throw new ApplicationException(
String.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.SessionGroupNotFound,
rtSession.SessionGroup.GroupUniqueId.ToString()));
}
// TODO: Modify ProdviderManager to take a constructor that does not require a Config and that just loads
// all providers in the Plugins directory, then move this code up to the MonitorWatcher constructor and pass the
// providerHandlers down as another argument to this constructor
ProviderManager providerManager = new ProviderManager(Config);
Dictionary <Guid, ProviderHandler> providerHandlers = providerManager.LoadProvider(new DirectoryInfo(Constants.PluginsFolderName));
ProviderHandler providerHandler;
if (!providerHandlers.TryGetValue(this.RTMigrationSource.UniqueId, out providerHandler))
{
throw new Exception(string.Format(CultureInfo.InvariantCulture,
MigrationToolkitResources.ProviderHandlerNotLoadedForMigrationSouce,
this.RTMigrationSource.FriendlyName));
}
Debug.Assert(providerHandler.Provider != null);
SyncMonitorProvider = providerHandler.Provider.GetService(typeof(ISyncMonitorProvider)) as ISyncMonitorProvider;
if (SyncMonitorProvider == null)
{
throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture,
MigrationToolkitResources.ProviderDoesNotImplementISyncMonitor,
providerHandler.ProviderName));
}
// Find the Session object corresponding to the RTSession
if (Config.SessionGroup != null && Config.SessionGroup.Sessions != null)
{
foreach (var aSession in Config.SessionGroup.Sessions.Session)
{
if (string.Equals(aSession.SessionUniqueId, rtSession.SessionUniqueId.ToString(), StringComparison.Ordinal))
{
Session = aSession;
break;
}
}
}
if (Session == null)
{
throw new Exception(string.Format(CultureInfo.InvariantCulture,
MigrationToolkitResources.SessionNotFoundForMigrationSource,
rtSession.SessionGroup.GroupUniqueId.ToString(), RTMigrationSource.FriendlyName));
}
Guid migrationSourceGuid = new Guid(isRightMigrationSource ? Session.RightMigrationSourceUniqueId : Session.LeftMigrationSourceUniqueId);
Microsoft.TeamFoundation.Migration.BusinessModel.MigrationSource migrationSource = Config.GetMigrationSource(migrationSourceGuid);
Session.MigrationSources.Add(migrationSourceGuid, migrationSource);
var serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(ITranslationService), new SyncMonitorTranslationService(Session));
// We pass null for the global Configuration to the ConfigurationService constructor because its not handy and not needed in this context
serviceContainer.AddService(typeof(ConfigurationService), new ConfigurationService(null, Session, migrationSourceGuid));
SyncMonitorProvider.InitializeServices(serviceContainer);
SyncMonitorProvider.InitializeClient(migrationSource);
int filterPairIndex = IsRightMigrationSource ? 1 : 0;
foreach (var filterPair in Session.Filters.FilterPair)
{
if (!filterPair.Neglect)
{
m_filterStrings.Add(VCTranslationService.TrimTrailingPathSeparator(filterPair.FilterItem[filterPairIndex].FilterString));
}
}
}
private ConflictResolutionResult ResolveBySubmitMissingChanges(
IServiceContainer serviceContainer,
MigrationConflict conflict,
ConflictResolutionRule rule,
out List <MigrationAction> actions)
{
actions = null;
var retVal = new ConflictResolutionResult(false, ConflictResolutionType.Other);
WITTranslationService translationService = serviceContainer.GetService(typeof(ITranslationService)) as WITTranslationService;
Debug.Assert(null != translationService, "translationService is not initialized or not a wit translation service");
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
RTSessionGroup rtSessionGroup = FindSessionGroupForConflictedAction(conflict, context);
if (null == rtSessionGroup)
{
return(retVal);
}
BM.BusinessModelManager bmm = new BM.BusinessModelManager();
BM.Configuration sessionGroupConfig = bmm.LoadConfiguration(rtSessionGroup.GroupUniqueId);
// find target-side migration source config
var parentChangeGroup = FindChangeGroupForConflictedAction(conflict, context);
Guid targetMigrationSourceId = parentChangeGroup.SourceUniqueId;
BM.MigrationSource targetMigrationSourceConfig = sessionGroupConfig.SessionGroup.MigrationSources[targetMigrationSourceId];
if (null == targetMigrationSourceConfig)
{
return(retVal);
}
// find source-side migration source config
RTSession rtSession = FindSessionForConflictedAction(conflict, context);
BM.Session parentSession = null;
foreach (BM.Session s in sessionGroupConfig.SessionGroup.Sessions.Session)
{
if (new Guid(s.SessionUniqueId).Equals(rtSession.SessionUniqueId))
{
parentSession = s;
break;
}
}
if (parentSession == null)
{
return(retVal);
}
Guid sourceMigrationSourceId = ((new Guid(parentSession.LeftMigrationSourceUniqueId)).Equals(targetMigrationSourceId))
? new Guid(parentSession.RightMigrationSourceUniqueId) : new Guid(parentSession.LeftMigrationSourceUniqueId);
BM.MigrationSource sourceMigrationSourceConfig = sessionGroupConfig.SessionGroup.MigrationSources[sourceMigrationSourceId];
if (null == sourceMigrationSourceConfig)
{
return(retVal);
}
string sourceServerUrl = sourceMigrationSourceConfig.ServerUrl;
string sourceTeamProject = sourceMigrationSourceConfig.SourceIdentifier;
string targetServerUrl = targetMigrationSourceConfig.ServerUrl;
string targetTeamProject = targetMigrationSourceConfig.SourceIdentifier;
string srcWorkItemIdStr = TfsMigrationWorkItemStore.GetSourceWorkItemId(conflict.ConflictedChangeAction);
Debug.Assert(!string.IsNullOrEmpty(srcWorkItemIdStr), "srcWorkItemId is null or empty");
int srcWorkItemId;
if (!int.TryParse(srcWorkItemIdStr, out srcWorkItemId))
{
return(retVal);
}
string srcRevRanges = rule.DataFieldDictionary[HistoryNotFoundSubmitMissingChangesAction.DATAKEY_REVISION_RANGE];
int[] sourceRevToSync = new int[0];
if (string.IsNullOrEmpty(srcRevRanges))
{
sourceRevToSync = ExtractMissingRevs(conflict.ConflictedChangeAction);
}
else
{
if (!IntegerRange.TryParseRangeString(srcRevRanges, out sourceRevToSync))
{
return(retVal);
}
}
if (sourceRevToSync.Length == 0)
{
return(retVal);
}
try
{
// compute delta from source side
TfsWITAnalysisProvider analysisProvider = new TfsWITAnalysisProvider(sourceServerUrl, sourceTeamProject);
WorkItem sourceWorkItem = analysisProvider.GetWorkItem(srcWorkItemId);
Hist.MigrationAction[] sourceRevDetails = new Hist.MigrationAction[sourceRevToSync.Length];
for (int revIndex = 0; revIndex < sourceRevToSync.Length; ++revIndex)
{
var details = new TfsWITRecordDetails(sourceWorkItem, sourceRevToSync[revIndex]);
SanitizeDetails(details);
translationService.MapWorkItemTypeFieldValues(
sourceWorkItem.Id.ToString(), details.DetailsDocument, sourceMigrationSourceId);
TfsConstants.ChangeActionId actionId = (sourceRevToSync[revIndex] == 1 ? TfsConstants.ChangeActionId.Add : TfsConstants.ChangeActionId.Edit);
sourceRevDetails[revIndex] = new Hist.MigrationAction(sourceWorkItem.Id.ToString(), details, actionId);
}
// migrate to target side
TfsWITMigrationProvider migrationProvider = new TfsWITMigrationProvider(targetServerUrl, targetTeamProject, string.Empty);
Hist.ConversionResult conversionResult = migrationProvider.ProcessChangeGroup(sourceRevDetails);
// update conversion history
ConversionResult convRslt = new ConversionResult(sourceMigrationSourceId, targetMigrationSourceId);
convRslt.ChangeId = HistoryNotFoundResolutionChangeId;
convRslt.ContinueProcessing = true;
foreach (var itemConvHist in conversionResult.ItemConversionHistory)
{
convRslt.ItemConversionHistory.Add(new ItemConversionHistory(
itemConvHist.SourceItemId, itemConvHist.SourceItemVersion, itemConvHist.TargetItemId, itemConvHist.TargetItemVersion));
}
parentChangeGroup.SessionRunReference.Load();
int sessionRunId = parentChangeGroup.SessionRun.Id;
convRslt.Save(sessionRunId, sourceMigrationSourceId);
}
catch (Exception ex)
{
TraceManager.TraceException(ex);
retVal.Comment = ex.ToString();
return(retVal);
}
}
retVal.Resolved = true;
return(retVal);
}
