public void OnAgentRegistrationUpdated(AgentConnection clientConnection, AgentRegistration registration)
{
if (AgentRegistrationUpdated != null)
{
AgentRegistrationUpdated.Invoke(clientConnection, registration);
}
}
public void OnAgentHealthcheckStatsUpdated(AgentConnection clientConnection, AgentHealthState agentHealthState, string message)
{
if (AgentHealthcheckStatsUpdated != null)
{
AgentHealthcheckStatsUpdated.Invoke(clientConnection, agentHealthState, message);
}
}
public void OnNodesUpdated(AgentConnection clientConnection, NodeNetwork updatedNodes)
{
if (NodesUpdated != null)
{
NodesUpdated.Invoke(clientConnection, updatedNodes);
}
}
public void ConnectToAgents(List <String> agentList)
{
foreach (string agentAddress in agentList)
{
string[] addressParts = agentAddress.Split(':');
AgentConnection agent = new AgentConnection(addressParts[0], addressParts[1]);
Session.AddAgent(agent);
Session.InitializeAgent(agent);
Timer reconnectionTimer = new Timer
{
AutoReset = true,
Interval = 3000
};
reconnectionTimer.Elapsed += (sender, args) =>
{
if (agent.State == WebSocketState.None || agent.State == WebSocketState.Aborted || agent.State == WebSocketState.Closed)
{
Session.ConnectAgent(agent);
}
};
reconnectionTimer.Start();
}
Session.InitializeSession();
}
private void MessageReceived(AgentConnection agent, string payload)
{
MessageEnvelope envelope;
try
{
envelope = JsonConvert.DeserializeObject <MessageEnvelope>(payload);
}
catch (Exception ex)
{
logger.Error(ex, $"Cannot deserialize message envelope from agent {agent.Address}");
return;
}
try
{
logger.Trace($"Processing {envelope.MessageType} message");
if (!agent.Processors.ContainsKey(envelope.MessageType))
{
logger.Fatal($"Unknown message type {envelope.MessageType} from agent {agent.Address}");
return;
}
var processor = agent.Processors[envelope.MessageType];
processor.ProcessMessage(envelope);
}
catch (Exception ex)
{
logger.Error(ex, $"Cannot process {envelope.MessageType} message from agent {agent.Address}");
}
}
private void ConnectionOpen(AgentConnection agent)
{
InitializeClientConnection(agent);
foreach (DispatcherBase dispatcher in agent.Dispatchers.Values)
{
dispatcher.Start();
}
logger.Info($"Connection opened for agent {agent.Address}");
OnAgentHealthcheckStatsUpdated(agent, new AgentHealthState(), string.Empty);
}
public void AddAgent(AgentConnection agent)
{
agent.Session = this;
agent.OnOpen += () => ConnectionOpen(agent);
agent.OnClose += () => ConnectionClose(agent);
agent.OnConnectionError += (message) => ConnectionError(agent, message);
agent.OnMessage += (payload) => MessageReceived(agent, payload);
if (!Agents.ContainsKey(agent.Address))
{
Agents.Add(agent.Address, agent);
}
}
public void AddClient(AgentConnection client)
{
client.Session = this;
client.OnOpen += () => ConnectionOpen(client);
client.OnClose += () => ConnectionClose(client);
client.OnConnectionError += (message) => ConnectionError(client, message);
client.OnMessage += (payload) => MessageReceived(client, payload);
if (!Agents.ContainsKey(client.Address))
{
Agents.Add(client.Address, client);
}
}
private void ConnectionClose(AgentConnection agent)
{
logger.Info($"The connection is no longer available");
OnAgentHealthcheckStatsUpdated(agent, new AgentHealthState(), string.Empty);
agent.Disconnect();
agent.Dispatchers.Clear();
agent.Processors.Clear();
foreach (DispatcherBase dispatcher in agent.Dispatchers.Values)
{
dispatcher.Stop();
}
logger.Info($"Connection closed for agent {agent.Address}");
}
private void InitializeClientConnection(AgentConnection agent)
{
//Configure processors
agent.Processors.Add(MessageType.AgentRegistration, new AgentRegistrationProcessor(agent));
agent.Processors.Add(MessageType.NodeStatistics, new NodeStatusProcessor(agent));
agent.Processors.Add(MessageType.ResourceFromAgent, new ResourceFromAgentProcessor(agent));
agent.Processors.Add(MessageType.AgentHealthcheck, new AgentHealthcheckProcessor(agent));
//Configure dispatchers
agent.Dispatchers.Add(MessageType.ClientRegistration, new ClientRegistrationDispatcher(agent, int.MaxValue));
agent.Dispatchers.Add(MessageType.NodeConfiguration, new NodeConfigurationDispatcher(agent, int.MaxValue));
agent.Dispatchers.Add(MessageType.ActionRequest, new NodeActionDispatcher(agent, 1000));
agent.Dispatchers.Add(MessageType.ResourceFromClient, new ResourceFromClientDispatcher(agent, 1000));
foreach (DispatcherBase dispatcher in agent.Dispatchers.Values)
{
dispatcher.Updated += agent.SendObject;
}
logger.Debug($"Connected Client {agent.Address}");
}
public void ConnectAgent(AgentConnection agent)
{
agent.Connect();
}
public void InitializeAgent(AgentConnection agent)
{
OnAgentHealthcheckStatsUpdated(agent, new AgentHealthState(), "Connecting...");
}
private void ConnectionError(AgentConnection agent, string message)
{
logger.Info($"Failed to connect to agent {agent.Address}");
OnAgentHealthcheckStatsUpdated(agent, new AgentHealthState(), message);
}
public void DisconnectAgent(AgentConnection agent)
{
agent.Disconnect();
}
public AgentConnection GetAgent(string agentAddress)
{
AgentConnection client = Session.Agents.FirstOrDefault(a => a.Key == agentAddress).Value;
return(client);
}
