public static void ChangeWorkSessionStatus(Message msg)
{
lock (locker) {
BeginUpdate();
try {
if (msg.Sender.IsProbablyShuttingDown() || msg.Sender.Status != WorkSessionServerStatus.Online)
{
return;
}
WorkSessionServerInfo existingServerInfo = All.GetOrAdd(msg.RoleInstanceId, msg.Sender);
var wsStatus = GetStatusFromOperation(msg.MessageOperation);
foreach (KeyValuePair <Guid, WorkSessionInfo> ws in msg.Sender.WorkSessions)
{
bool found = existingServerInfo.WorkSessions.TryGetValue(ws.Key, out WorkSessionInfo updatedWorkSessionInfo);
if (found)
{
#if DEBUG
Diagnostic.Logger.Log(string.Format("Change worksession status from {0} to {1}", updatedWorkSessionInfo.Status.ToString(), wsStatus));
#endif
updatedWorkSessionInfo.SetStatus(wsStatus);
}
}
} finally {
EndUpdate();
}
}
}
static void RaiseEvent(string eventName, WorkSessionServerInfo server)
{
if (serverEvents.ContainsKey(eventName) && serverEvents[eventName] != null)
{
serverEvents[eventName](server);
}
}
public static void UpdateAllWorkSessionsFromOneServer(Message msg)
{
lock (locker) {
BeginUpdate();
try {
HashSet <string> updatedServerIDs = new HashSet <string>();
foreach (WorkSessionServerInfo serverInfo in msg.RegisteredServers)
{
if (serverInfo.IsProbablyShuttingDown())
{
continue;
}
if (!All.TryGetValue(serverInfo.RoleInstanceId, out WorkSessionServerInfo existingServer))
{
if (msg.Sender.RoleInstanceId == serverInfo.RoleInstanceId || serverInfo.WorkSessions.Count() > 0)
{
#if DEBUG
Diagnostic.Logger.Log(string.Format("UpdateAll adds server {0}", serverInfo.RoleInstanceId));
#endif
}
else
{
continue;
}
}
WorkSessionServerInfo currentServer = All.GetOrAdd(serverInfo.RoleInstanceId, serverInfo);
HashSet <Guid> updatedWorkSessionIDs = new HashSet <Guid>();
foreach (WorkSessionInfo workSessionInfo in serverInfo.WorkSessions.Select(v => v.Value))
{
#if DEBUG
if (!currentServer.WorkSessions.TryGetValue(workSessionInfo.WorkSessionID, out WorkSessionInfo existingWorkSession))
{
Diagnostic.Logger.Log(string.Format("UpdateAll adds worksession {0} on server {1}", existingWorkSession.WorkSessionID, currentServer.RoleInstanceId));
}
#endif
currentServer.WorkSessions.GetOrAdd(workSessionInfo.WorkSessionID, workSessionInfo);
updatedWorkSessionIDs.Add(workSessionInfo.WorkSessionID);
}
if (currentServer.RoleInstanceId == msg.Sender.RoleInstanceId)
{
foreach (WorkSessionInfo workSessionInfo in currentServer.WorkSessions.Select(w => w.Value))
{
if (!updatedWorkSessionIDs.Contains(workSessionInfo.WorkSessionID))
{
currentServer.WorkSessions.TryRemove(workSessionInfo.WorkSessionID, out WorkSessionInfo deletedWorkSessionInfo);
#if DEBUG
Diagnostic.Logger.Log(string.Format("UpdateAll removes worksession {0} from server {1}", workSessionInfo.WorkSessionID, currentServer.RoleInstanceId));
#endif
}
}
}
updatedServerIDs.Add(serverInfo.RoleInstanceId);
}
} finally {
EndUpdate();
}
}
}
void SetSenderInfo(WorkSessionServerInfo sender)
{
if (RegisteredServers.Count == 0 || Sender == null || Sender.RoleInstanceId != RoleInstanceId)
{
RegisteredServers.Add(sender);
}
Sender.GetServerParameters();
}
public WorkSessionServerInfo(WorkSessionServerInfo serverInfo) : this()
{
RoleInstanceId = serverInfo.RoleInstanceId;
HostServerName = serverInfo.HostServerName;
HostServerIP = serverInfo.HostServerIP;
LastUpdateTime = serverInfo.LastUpdateTime;
RemainingMemory = serverInfo.RemainingMemory;
Status = serverInfo.Status;
}
public static void RemoveWorkSessionServer(WorkSessionServerInfo server)
{
lock (locker) {
BeginUpdate();
try {
bool found = All.TryGetValue(server.RoleInstanceId, out WorkSessionServerInfo deletedServerInfo);
if (found)
{
All.TryRemove(server.RoleInstanceId, out deletedServerInfo);
}
} finally {
EndUpdate();
}
}
}
static void EnsureWorkSessionsAreNotDuplicated(WorkSessionServerInfo workSessionServerInfo)
{
lock (locker) {
foreach (KeyValuePair <Guid, WorkSessionInfo> ws in workSessionServerInfo.WorkSessions)
{
IEnumerable <WorkSessionServerInfo> workSessionServers = GetWorkSessionServersByWorkSessionID(ws.Key);
foreach (var server in workSessionServers)
{
if (server.RoleInstanceId != workSessionServerInfo.RoleInstanceId)
{
server.WorkSessions.TryRemove(ws.Key, out WorkSessionInfo removedWorkSession);
}
}
}
}
}
static void AddWorkSessionServer(WorkSessionServerInfo server)
{
lock (locker) {
BeginUpdate();
try {
WorkSessionServerInfo serverWithoutWorkSessions = new WorkSessionServerInfo(server);
All.AddOrUpdate(server.RoleInstanceId, serverWithoutWorkSessions, (k, s) => {
s.HostServerIP = serverWithoutWorkSessions.HostServerIP;
s.HostServerName = serverWithoutWorkSessions.HostServerName;
s.LastUpdateTime = DateTime.Now;
s.RemainingMemory = serverWithoutWorkSessions.RemainingMemory;
s.SetStatus(serverWithoutWorkSessions.Status);
return(s);
});
} finally {
EndUpdate();
}
}
}
public static void AddWorkSession(Message msg)
{
lock (locker) {
BeginUpdate();
try {
WorkSessionServerInfo existingServerInfo = All.GetOrAdd(msg.RoleInstanceId, msg.Sender);
foreach (KeyValuePair <Guid, WorkSessionInfo> ws in msg.Sender.WorkSessions)
{
#if DEBUG
Diagnostic.Logger.Log(string.Format("Add worksession {0} to server {1}", ws.Key, existingServerInfo.RoleInstanceId));
#endif
existingServerInfo.WorkSessions.AddOrUpdate(ws.Key, ws.Value, (k, w) => {
w.DocumentId = ws.Value.DocumentId;
w.ProcessedTime = ws.Value.ProcessedTime;
w.SetStatus(ws.Value.Status);
return(w);
});
}
EnsureWorkSessionsAreNotDuplicated(existingServerInfo);
} finally {
EndUpdate();
}
}
}
static void RaiseServerRemovedEvent(WorkSessionServerInfo server)
{
RaiseEvent(ServerRemovedEventKey, server);
}
