public void sendGoodbye()
{
Goodbye goodbye = new Goodbye(myAddress, myNickname);
sentAndReceivedGoodbyes.Add(goodbye.nickname);
udpSender.sendGoodbye(goodbye);
}
static void Main(string[] args)
{
Professional specialist1 = new Professional("Иван", "Иванов", 20, "Футбол", 2);
Professional specialist2 = new Professional("Петр", "Петров", 22, "Баскетбол", 3);
specialist2.Notify += (string mes) => Console.WriteLine(mes);
specialist1.Print();
specialist2.Print();
Welcome welcome = Hello;
welcome += Bye;
welcome(specialist1.GetFirstName());
welcome -= Bye;
welcome(specialist1.GetFirstName());
welcome -= Hello;
Goodbye handler = delegate(string firstName)
{
Console.WriteLine("Пока, " + firstName);
};
handler(specialist1.GetFirstName());
specialist1.ShowEx();
Console.ReadKey();
}
public override async Task StopAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Saying Goodbye");
var message = new Goodbye();
GreetingActor.Tell(message);
await ActorSystem.Terminate();
}
public void sendGoodbye(Goodbye goodbye)
{
string gb = serialize(goodbye);
chatUDPController.MyNodes.ForEach(p => sendCommunication(gb, p.addr, p.port));
/*foreach (Peer p in chatUDPController.myNodes)
* {
* sendCommunication(gb, p.addr, p.port);
* }*/
}
public void sendReceivedGoodbye(Goodbye goodbye)
{
// retirer nickname from list participant
if (participants.Any(p => p.Equals(goodbye.nickname)))
{
participants.Remove(goodbye.nickname);
System.Windows.Application.Current.Dispatcher.Invoke((Action)(() => mainWindow.removeParticipant(goodbye.nickname)));
}
// broadcast goodbye
udpSender.sendGoodbye(goodbye);
}
private void readIncomingCommunication(string msg)
{
mutex.WaitOne();
var data = (JObject)JsonConvert.DeserializeObject(msg);
Console.WriteLine(data["type"]);
string type = data["type"].Value <string>();
MemoryStream stream = GenerateStreamFromString(msg);
stream.Position = 0;
// TODO : faire vérification si communication est bien formée
// vérifier type message
if (type.Contains(ECommunicationType.HELLO))
{
Hello receivedHello = new Hello();
List <Peer> listeNoeudsVoisins;
if (type == ECommunicationType.HELLO_A)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Hello_A));
receivedHello = (Hello_A)ser.ReadObject(stream);
listeNoeudsVoisins = receivedHello.pairs;
// si hello qui quelqu'un m'a envoyé, vérifier qu'il n'a pas été déjà reçu à moins de 10 sec
// si non, répondre le hello reçu avec la liste noeuds
//List<Peer> liste = helloSenders.Where(p => (p.Key.addr == receivedHello.addr_source)).Select(p => p.Key).ToList();
if (chatUDPController.isANewReceivedHello(receivedHello, type) /*liste.Count == 0*/)
{
//List<Peer> listeNoeudsVoisins = receivedHello.pairs;
/*if (receivedHello.GetType() == typeof(Hello_A))
* {*/
Hello_R hello_r = new Hello_R(myAddress, myPort, chatUDPController.MyNodes);
Peer peer_dest = new Peer(receivedHello.addr_source, receivedHello.port_source);
//chatUDPController.helloSenders.Add(peer_dest, DateTime.Now);
chatUDPController.receivedHelloAList.Add(peer_dest, DateTime.Now);
chatUDPController.sendHello(hello_r, peer_dest);
// A TRAITER : Sauf si un noeuds fait un HELLO avec une liste de paire vide (isolé) auquel cas on le rajoute automatiquement
// si source contient que moi dans sa liste de noeuds, l'ajouter à ma liste de noeuds (même que ça dépasse 4)
// si aucun noeud voisin ou 1 seul et moi même
chatUDPController.addPeerToCurrentNeighbors(peer_dest, listeNoeudsVoisins.Count == 0 || (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr.Equals(myAddress) && listeNoeudsVoisins[0].port == myPort));
/*if ((listeNoeudsVoisins.Count == 0
|| (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr == myAddress)) /*listeNoeudsVoisins.Where(p => (p.addr == adresse)).ToList().Count > 0)*
|| && !chatUDPController.myNodes.Contains(peer_dest))
|| {
|| chatUDPController.myNodes.Add(peer_dest);
|| }*/
//}
// récuperer sa liste de noeuds et ajouter à la sienne
//fillNeighbours(listeNoeudsVoisins, type);
listeNoeudsVoisins.ForEach(p => chatUDPController.addPeerToCurrentNeighbors(p, false));
}
}
else if (type == ECommunicationType.HELLO_R)
{
if (chatUDPController.isANewReceivedHello(receivedHello, type))
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Hello_R));
receivedHello = (Hello_R)ser.ReadObject(stream);
listeNoeudsVoisins = receivedHello.pairs;
Peer peer_dest = new Peer(receivedHello.addr_source, receivedHello.port_source);
chatUDPController.receivedHelloRList.Add(peer_dest, DateTime.Now);
//chatUDPController.addPeerToCurrentNeighbors(peer_dest, listeNoeudsVoisins.Count == 0 || (listeNoeudsVoisins.Count == 1 && listeNoeudsVoisins[0].addr == myAddress));
// récuperer sa liste de noeuds et ajouter à la sienne
//fillNeighbours(listeNoeudsVoisins, type);
listeNoeudsVoisins.ForEach(p => chatUDPController.addPeerToCurrentNeighbors(p, false));
}
}
}
else if (type == ECommunicationType.MESSAGE)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Message));
Message message = (Message)ser.ReadObject(stream);
// vérifier si message pas encore reçu
if (chatUDPController.isANewReceivedMessage(message) /*sentAndReceivedMessages.Where(m => m == message.hash).ToList().Count == 0*/)
{
treatReceivedMessage(message);
}
}
else if (type == ECommunicationType.PING)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Ping));
Ping ping = (Ping)ser.ReadObject(stream);
chatUDPController.sendPong(ping.addr_source, ping.port_source);
}
else if (type == ECommunicationType.PONG)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Pong));
Pong pong = (Pong)ser.ReadObject(stream);
//chatUDPController.receivedPongs.Add(pong);
if (chatUDPController.SentPings.ContainsKey(pong.addr_source + pong.port_source))
{
chatUDPController.SentPings[pong.addr_source + pong.port_source] = true;
}
// TODO : ajouter réponse pong à ping correspondant
/*if (chatUDPController.dictPingPong.ContainsKey(pong.addr_source + pong.port_source))
* {
* chatUDPController.dictPingPong.Remove(pong.addr_source + pong.port_source);
* }*/
// chatUDPController.
}
else if (type == ECommunicationType.GOODBYE)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Goodbye));
Goodbye goodbye = (Goodbye)ser.ReadObject(stream);
// vérifier si goodbye pas encore reçu
if (chatUDPController.isANewReceivedGoodbye(goodbye) /*sentAndReceivedMessages.Where(m => m == message.hash).ToList().Count == 0*/)
{
chatUDPController.sentAndReceivedGoodbyes.Add(goodbye.nickname);
chatUDPController.sendReceivedGoodbye(goodbye);
}
}
else
{
Console.WriteLine("Default case");
}
mutex.ReleaseMutex();
}
public Boolean isANewReceivedGoodbye(Goodbye goodbye)
{
return(!sentAndReceivedGoodbyes.Any(g => g == goodbye.nickname)); //.ToList().Count == 0;
}
public bool Greet(Goodbye message)
{
_logger.Info("Goodbye from GreetingActor");
return(true);
}
private void Leave()
{
Goodbye g = new Goodbye();
g.sayGoodBye();
}
