private void ProcessTeamListMessage(NodeMessage message)
{
if (_serviceBusTeamListMessageSubscription != null)
{
_serviceBusTeamListMessageSubscription.Dispose();
_serviceBusTeamListMessageSubscription = null;
}
if (message != null)
{
_logger.LogInformation(Resources.Info_NodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType);
var teamList = (IEnumerable <string>)message.Data;
if (_teamsToInitialize.Setup(teamList))
{
PlanningPoker.SetTeamsInitializingList(teamList);
}
RequestTeams(message.SenderNodeId);
}
else
{
EndInitialization();
}
}
private void OnScrumTeamCreated(NodeMessage message)
{
try
{
var scrumTeam = DeserializeScrumTeam((string)message.Data);
_logger.LogInformation(Resources.Info_ScrumTeamCreatedNodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType, scrumTeam.Name);
if (!_teamsToInitialize.ContainsOrNotInit(scrumTeam.Name))
{
try
{
_processingScrumTeamName = scrumTeam.Name;
using (var teamLock = PlanningPoker.AttachScrumTeam(scrumTeam))
{
}
}
finally
{
_processingScrumTeamName = null;
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, Resources.Error_ScrumTeamCreatedNodeMessage, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType);
}
}
private void SetProcessMessagesHandler()
{
try
{
using (var teamLock = PlanningPoker.GetScrumTeam(TeamName))
{
teamLock.Lock();
var team = teamLock.Team;
var member = team.FindMemberOrObserver(MemberName);
// Removes old messages, which the member has already read, from the member's message queue.
while (member.HasMessage && member.Messages.First().Id <= LastMessageId)
{
member.PopMessage();
}
// Updates last activity on member to record time, when member checked for new messages.
// also notifies to save the team into repository
member.UpdateActivity();
PlanningPoker.GetMessagesAsync(member, ProcessMessages);
}
}
catch (Exception ex)
{
ThrowException(ex);
}
}
private NodeMessage CreateTeamCreatedMessage(string teamName)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
return(new NodeMessage(NodeMessageType.TeamCreated)
{
Data = SerializeScrumTeam(team)
});
}
}
private void EndInitialization()
{
_teamsToInitialize.Clear();
PlanningPoker.EndInitialization();
_logger?.LogInformation(Resources.Info_PlanningPokerAzureNodeInitialized, NodeId);
var serviceBusMessages = ServiceBus.ObservableMessages.Where(m => !string.Equals(m.SenderNodeId, NodeId, StringComparison.OrdinalIgnoreCase));
var requestTeamListMessages = serviceBusMessages.Where(m => m.MessageType == NodeMessageType.RequestTeamList);
_serviceBusRequestTeamListMessageSubscription = requestTeamListMessages.Subscribe(ProcessRequestTeamListMesage);
var requestTeamsMessages = serviceBusMessages.Where(m => m.MessageType == NodeMessageType.RequestTeams);
_serviceBusRequestTeamsMessageSubscription = requestTeamsMessages.Subscribe(ProcessRequestTeamsMessage);
}
private void OnEstimationCanceledMessage(string teamName)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
try
{
_processingScrumTeamName = team.Name;
team.ScrumMaster.CancelEstimation();
}
finally
{
_processingScrumTeamName = null;
}
}
}
private void OnMemberDisconnectedMessage(string teamName, ScrumTeamMemberMessage message)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
try
{
_processingScrumTeamName = team.Name;
team.Disconnect(message.MemberName);
}
finally
{
_processingScrumTeamName = null;
}
}
}
private void OnMemberJoinedMessage(string teamName, ScrumTeamMemberMessage message)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
try
{
_processingScrumTeamName = team.Name;
team.Join(message.MemberName, string.Equals(message.MemberType, typeof(Observer).Name, StringComparison.OrdinalIgnoreCase));
}
finally
{
_processingScrumTeamName = null;
}
}
}
private NodeMessage CreateTeamCreatedMessage(string teamName)
{
try
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
return(new NodeMessage(NodeMessageType.TeamCreated)
{
Data = SerializeScrumTeam(team)
});
}
}
catch (Exception ex)
{
_logger.LogError(ex, Resources.Error_CreateTeamNodeMessage, teamName, NodeId);
return(null);
}
}
private void OnMemberActivityMessage(string teamName, ScrumTeamMemberMessage message)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
try
{
_processingScrumTeamName = team.Name;
var observer = team.FindMemberOrObserver(message.MemberName);
if (observer != null)
{
observer.UpdateActivity();
}
}
finally
{
_processingScrumTeamName = null;
}
}
}
private void OnMemberEstimatedMessage(string teamName, ScrumTeamMemberEstimationMessage message)
{
using (var teamLock = PlanningPoker.GetScrumTeam(teamName))
{
teamLock.Lock();
var team = teamLock.Team;
try
{
_processingScrumTeamName = team.Name;
var member = team.FindMemberOrObserver(message.MemberName) as Member;
if (member != null)
{
member.Estimation = new Estimation(message.Estimation);
}
}
finally
{
_processingScrumTeamName = null;
}
}
}
private void OnScrumTeamCreated(NodeMessage message)
{
var scrumTeamData = (byte[])message.Data;
var scrumTeam = ScrumTeamHelper.DeserializeScrumTeam(scrumTeamData, PlanningPoker.DateTimeProvider);
_logger?.LogInformation(Resources.Info_ScrumTeamCreatedNodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType, scrumTeam.Name);
if (!_teamsToInitialize.ContainsOrNotInit(scrumTeam.Name))
{
try
{
_processingScrumTeamName = scrumTeam.Name;
using (var teamLock = PlanningPoker.AttachScrumTeam(scrumTeam))
{
}
}
finally
{
_processingScrumTeamName = null;
}
}
}
private void ProcessInitializeTeamMessage(NodeMessage message)
{
var scrumTeamData = message.Data as byte[];
if (scrumTeamData != null)
{
var scrumTeam = ScrumTeamHelper.DeserializeScrumTeam(scrumTeamData, PlanningPoker.DateTimeProvider);
_logger?.LogInformation(Resources.Info_ScrumTeamCreatedNodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType, scrumTeam.Name);
_teamsToInitialize.Remove(scrumTeam.Name);
PlanningPoker.InitializeScrumTeam(scrumTeam);
}
else
{
// team does not exist anymore
_teamsToInitialize.Remove((string)message.Data);
}
if (_teamsToInitialize.IsEmpty)
{
EndInitialization();
}
}
private void ProcessRequestTeamsMessage(NodeMessage message)
{
_logger?.LogInformation(Resources.Info_NodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType);
var scrumTeamNames = (IEnumerable <string>)message.Data;
foreach (var scrumTeamName in scrumTeamNames)
{
try
{
string scrumTeamData = null;
try
{
using (var teamLock = PlanningPoker.GetScrumTeam(scrumTeamName))
{
teamLock.Lock();
scrumTeamData = SerializeScrumTeam(teamLock.Team);
}
}
catch (Exception)
{
scrumTeamData = null;
}
var initializeTeamMessage = new NodeMessage(NodeMessageType.InitializeTeam)
{
RecipientNodeId = message.SenderNodeId,
Data = scrumTeamData != null ? scrumTeamData : (DeletedTeamPrefix + scrumTeamName)
};
SendNodeMessage(initializeTeamMessage);
}
catch (Exception)
{
}
}
}
private void ProcessInitializeTeamMessage(NodeMessage message)
{
var scrumTeamData = (string)message.Data;
if (scrumTeamData.StartsWith(DeletedTeamPrefix, StringComparison.Ordinal))
{
// team does not exist anymore
var teamName = scrumTeamData.Substring(DeletedTeamPrefix.Length);
_teamsToInitialize.Remove(teamName);
}
else
{
var scrumTeam = DeserializeScrumTeam(scrumTeamData);
_logger?.LogInformation(Resources.Info_ScrumTeamCreatedNodeMessageReceived, NodeId, message.SenderNodeId, message.RecipientNodeId, message.MessageType, scrumTeam.Name);
_teamsToInitialize.Remove(scrumTeam.Name);
PlanningPoker.InitializeScrumTeam(scrumTeam);
}
if (_teamsToInitialize.IsEmpty)
{
EndInitialization();
}
}
