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

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

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())
                {
                    //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)
        {
            throw new NotImplementedException();
        }

    }
}