source: branches/thasling/DistributedGA/DistributedGA.Core/Implementation/PeerNetworkMessageHandler.cs @ 13538

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net;
using System.Text.RegularExpressions;
using DistributedGA.Core.Domain;
using DistributedGA.Core.Interface;

namespace DistributedGA.Core.Implementation {
  public class PeerNetworkMessageHandler : IMessageHandler {
    //own peer-instance Information
    private PeerInfo ownInstance = null;

    //uses peer-list from IPeerListManager to decide which peers to contact
    private IPeerListManager peerListManager;

    //uses IMessageSender to send populations to peers
    private IMessageSender sender = null;

    //provides current population for the higher layer IMigrationOperator
    //to queues are used to gather and and provide population more efficiently
    private ConcurrentQueue<SolutionInfo> collectedResults1;
    private ConcurrentQueue<SolutionInfo> collectedResults2;
    private bool collectingInFirstQueue = true; //currently first queue is filled with recieved populations

    //uses IMessageService for recieving population from one peer at once
    private IMessageService host = null;

    public void Init() {
      try {
        ownInstance = new PeerInfo() {
          IpAddress = GetExternalIpAddress(),
          Port = 0,
          ProblemInstance = "TestProblem"
        }; // TODO: get own peerinfo

        collectedResults1 = new ConcurrentQueue<SolutionInfo>();
        collectedResults2 = new ConcurrentQueue<SolutionInfo>();

        host = new WcfMessageService();
        ownInstance.Port = host.Init(ownInstance.IpAddress); //getting port, on which service is hostet
        host.OnPopulationRecieved += new EventHandler<MessageRecieveEventArgs>(OnPopulationRecieved);

        peerListManager = new WcfPeerListManager();
        //peerListManager = new TestPeerListManager();
        peerListManager.Init(ownInstance);

        sender = new WcfMessageSender();
        sender.Init(ownInstance);

      } catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.Init", ex);
      }
    }

    public void PublishMigrationInfo(SolutionInfo[] population) {
      try {
        foreach (PeerInfo peer in peerListManager.GetPeerList()) {
          //HACK: manipulate for monitoring in test
          foreach (SolutionInfo si in population) {
            si.IterationNumber = ownInstance.Port;
          }
          //maybe something will go wrong during network communication...
          try {
            //TODO: NEEDED WHEN PEER IS IN LAN, TOO????
            //Note: If IP is same as own: it is a "localhost"
            if (peer.IpAddress.Equals(ownInstance.IpAddress)) {
              peer.IpAddress = "localhost";
            }
            sender.SendPopulation(peer, population);

          } catch (Exception ex) {
            //TBD
          }
        }
      } catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.PublishMigrationInfo", ex);
      }
    }

    public SolutionInfo[] GetMigrationInfo() {
      try {
        List<SolutionInfo> res = new List<SolutionInfo>();
        ConcurrentQueue<SolutionInfo> source = null;
        SolutionInfo item = null;
        if (collectingInFirstQueue) {
          collectingInFirstQueue = false; //switching queue
          source = collectedResults1;
        } else {
          collectingInFirstQueue = true; //switching queue
          source = collectedResults2;
        }
        //creating resultset
        while (!source.IsEmpty) {
          if (source.TryDequeue(out item)) {
            res.Add(item);
          }
        }
        return res.ToArray();
      } catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.GetMigrationInfo", ex);
        return null;
      }
    }

    public PeerInfo GetPeerInfo() {
      return ownInstance;
    }

    public List<PeerInfo> GetCurrentNetwork() {
      return peerListManager.GetPeerList();
    }

    private string GetExternalIpAddress() {
      try {
        string externalIP;
        externalIP = (new WebClient()).DownloadString("http://checkip.dyndns.org/");
        externalIP = (new Regex(@"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"))
                     .Matches(externalIP)[0].ToString();
        return externalIP;
      } catch { return null; }
    }

    private void OnPopulationRecieved(object sender, MessageRecieveEventArgs e) {
      if (e != null) {
        foreach (SolutionInfo si in e.Population) {
          if (collectingInFirstQueue) {
            collectedResults1.Enqueue(si);
          } else {
            collectedResults2.Enqueue(si);
          }
        }
      }
    }

    private void AddError(string source, Exception ex) {
      if (peerListManager != null) {
        try {
          peerListManager.SendLogToServer(string.Concat("Source: ", source, ", Exception: ", ex.Message));
        } catch { }
      }
    }

  }
}